示例#1
0
        public static CompleteMultipartUploadResult UploadMultipart
        (
            IOssClientBuilder clientBuilder,
            string bucketName,
            string objectName,
            string fileToUpload,
            int partSize = DEFAULT_PART_SIZE,
            EventHandler <StreamTransferProgressArgs> streamTransferProgress = null,
            CancellationToken cancellationToken = default(CancellationToken)
        )
        {
            CompleteMultipartUploadResult retVal = null;

            if (clientBuilder == null)
            {
                throw new ArgumentNullException(nameof(clientBuilder));
            }

            long fileSize = new FileInfo(fileToUpload).Length;
            long progressUpdateInterval = (fileSize / 100 + 4096) / 4096 * 4096;

            var client = clientBuilder.Build(o =>
            {
                o.ProgressUpdateInterval = progressUpdateInterval;
            });

            var uploadId = InitiateMultipartUpload(client, bucketName, objectName);

            using (var cleaner = new MultipartCleaner(client, bucketName, objectName, uploadId))
            {
                var partETags = UploadParts(client, bucketName, objectName, fileToUpload, uploadId, partSize,
                                            (s, e) =>
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    streamTransferProgress?.Invoke(s, e);
                });
                retVal = CompleteUploadPart(client, bucketName, objectName, uploadId, partETags);
                cleaner.Complete();
            }
#if DEBUG
            if (OutputDebugInfo)
            {
                Console.WriteLine("Multipart put object:{0} succeeded", objectName);
            }
#endif
            return(retVal);
        }
示例#2
0
        public static CompleteMultipartUploadResult UploadMultipart
        (
            IOssClientBuilder clientBuilder,
            string bucketName,
            string objectName,
            Stream streamToUpload,
            Action <MultipartUploadOptions> options = null,
            EventHandler <StreamTransferProgressArgs> streamTransferProgress = null,
            CancellationToken cancellationToken = default(CancellationToken)
        )
        {
            CompleteMultipartUploadResult retVal = null;

            if (clientBuilder == null)
            {
                throw new ArgumentNullException(nameof(clientBuilder));
            }
            if (streamToUpload == null)
            {
                throw new ArgumentNullException(nameof(streamToUpload));
            }

            MultipartUploadOptions uploadOptions = new MultipartUploadOptions();

            options?.Invoke(uploadOptions);
            int partSize   = Math.Max(DEFAULT_PART_SIZE, uploadOptions.PartSize);
            var streamMode = uploadOptions.StreamMode;

            long fileSize = streamToUpload.Length;
            long progressUpdateInterval = (fileSize / 100 + 4096) / 4096 * 4096;

            if (streamMode == MultipartStreamMode.Auto || streamMode == MultipartStreamMode.PartialFileStream)
            {
                if (streamToUpload is FileStream && streamToUpload.CanSeek && streamToUpload.CanRead)
                {
                    streamMode = MultipartStreamMode.PartialFileStream;
                }
                else if (streamToUpload.CanRead)
                {
                    streamMode = MultipartStreamMode.SequenceInputStream;
                }
            }
            if (streamMode == MultipartStreamMode.PartialFileStream)
            {
                var client = clientBuilder.Build(o =>
                {
                    o.ProgressUpdateInterval = progressUpdateInterval;
                });

                var uploadId = InitiateMultipartUpload(client, bucketName, objectName);
                using (var cleaner = new MultipartCleaner(client, bucketName, objectName, uploadId))
                {
                    var partETags = UploadParts(client, bucketName, objectName, streamToUpload, uploadId, partSize,
                                                (s, e) =>
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        streamTransferProgress?.Invoke(s, e);
                    });
                    retVal = CompleteUploadPart(client, bucketName, objectName, uploadId, partETags);
                    cleaner.Complete();
                }
            }
            else if (streamMode == MultipartStreamMode.SequenceInputStream)
            {
                var client = clientBuilder.Build(o =>
                {
                    o.ProgressUpdateInterval = progressUpdateInterval;
                });

                var uploadId = InitiateMultipartUpload(client, bucketName, objectName);
                using (var cleaner = new MultipartCleaner(client, bucketName, objectName, uploadId))
                {
                    var partETags = UploadPartsWithCache(client, bucketName, objectName, streamToUpload, uploadId, partSize,
                                                         (s, e) =>
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        streamTransferProgress?.Invoke(s, e);
                    });
                    retVal = CompleteUploadPart(client, bucketName, objectName, uploadId, partETags);
                    cleaner.Complete();
                }
            }
            else
            {
                throw new ArgumentException("Stream Type is not supported", nameof(streamToUpload));
            }
#if DEBUG
            if (OutputDebugInfo)
            {
                Console.WriteLine("Multipart put object:{0} succeeded", objectName);
            }
#endif
            return(retVal);
        }