C# CloudBlockBlob.PutBlockListAsync方法代码示例

        private static async Task CreateForTestAsync(CloudBlockBlob blob, int blockCount, int blockSize, bool commit = true)
        {
            byte[] buffer = GetRandomBuffer(blockSize);
            List<string> blocks = GetBlockIdList(blockCount);

            foreach (string block in blocks)
            {
                using (MemoryStream stream = new MemoryStream(buffer))
                {
                    await blob.PutBlockAsync(block, stream.AsInputStream(), null);
                }
            }

            if (commit)
            {
                await blob.PutBlockListAsync(blocks);
            }
        }

        private static async Task AppendToBlob(CloudBlockBlob blockBlob, string content, string md5)
        {
            var leaseId = await blockBlob.AcquireLeaseAsync(TimeSpan.FromSeconds(30), null);
            var access = AccessCondition.GenerateLeaseCondition(leaseId);
            var options = new BlobRequestOptions();
            var context = new OperationContext();

            try
            {
                var blockId = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
                using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(content)))
                {
                    stream.Position = 0;
                    await blockBlob.PutBlockAsync(blockId, stream, md5, access, options, context);
                }

                var blockList = await blockBlob.DownloadBlockListAsync(BlockListingFilter.Committed, access, options, context);
                var blockIds = blockList.Select(x => x.Name).ToList();
                blockIds.Add(blockId);
                await blockBlob.PutBlockListAsync(blockIds, access, options, context);
            }
            catch(Exception ex)
            {
                //TODO - logging
            }
            finally
            {
                await blockBlob.ReleaseLeaseAsync(access);
            }
        }

 /// <summary>
 /// Test block blob creation (block list setting), expecting lease failure.
 /// </summary>
 /// <param name="testBlob">The block blob.</param>
 /// <param name="blockList">An appropriate block list to set.</param>
 /// <param name="testAccessCondition">The failing access condition to use.</param>
 /// <param name="expectedErrorCode">The expected error code.</param>
 /// <param name="description">The reason why these calls should fail.</param>
 private async Task BlockBlobWriteExpectLeaseFailureAsync(CloudBlockBlob testBlob, IEnumerable<string> blockList, AccessCondition testAccessCondition, HttpStatusCode expectedStatusCode, string expectedErrorCode, string description)
 {
     OperationContext operationContext = new OperationContext();
     await TestHelper.ExpectedExceptionAsync(
         async () => await testBlob.PutBlockListAsync(blockList, testAccessCondition, null /* options */, operationContext),
         operationContext,
         description + " (Put Block List)",
         expectedStatusCode,
         expectedErrorCode);
 }

 /// <summary>
 /// Test block blob creation (set block list), expecting success.
 /// </summary>
 /// <param name="testBlob">The block blob.</param>
 /// <param name="blockList">The block list to set.</param>
 /// <param name="testAccessCondition">The access condition to use.</param>
 private async Task BlockBlobWriteExpectSuccessAsync(CloudBlockBlob testBlob, IEnumerable<string> blockList, AccessCondition testAccessCondition)
 {
     await testBlob.PutBlockListAsync(blockList, testAccessCondition, null /* options */, null);
 }

        /// <summary>
        /// Sends every chunk of the .fcs file and sends an sms to the user
        /// </summary>
        /// <param name="model"></param>
        /// <param name="blockBlob"></param>
        /// <returns></returns>
        private async Task<ActionResult> CommitAllChunks(CloudFile model, CloudBlockBlob blockBlob)
        {
            model.IsUploadCompleted = true;

            var errorInOperation = false;

            try
            {
                var blockList = Enumerable.Range(1, (int)model.BlockCount).ToList().Select(rangeElement =>
                               Convert.ToBase64String(Encoding.UTF8.GetBytes(
                               string.Format(CultureInfo.InvariantCulture, "{0:D4}", rangeElement))));

                //model.BlockBlob.PutBlockListAsync(blockList);
                await blockBlob.PutBlockListAsync(blockList);

                var duration = DateTime.Now - model.StartTime;

                float fileSizeInKb = model.Size / 1024;

                var fileSizeMessage = fileSizeInKb > 1024 ?
                    string.Concat((fileSizeInKb / 1024).ToString(CultureInfo.CurrentCulture), " MB") :
                    string.Concat(fileSizeInKb.ToString(CultureInfo.CurrentCulture), " KB");

                var message = string.Format(CultureInfo.CurrentCulture,
                    "File uploaded successfully. {0} took {1} seconds to upload\n",
                    fileSizeMessage, duration.TotalSeconds);

                //Get the user
                var user = GetUser();
                //var fcsPath = user.LastName.ToLower() + "-" + user.FirstName.ToLower() + "-" + user.Id + "/" + model.FileName;
                var fcsPath = user.LastName.ToLower() + "-" + user.FirstName.ToLower() + "/" + model.FileName;

                var storedPatient = _context.Patients.First(x => x.Id == model.Patient);

                var analysis = new Analysis
                {
                    Date = DateTime.Now.Date,
                    FcsFilePath = fcsPath,
                    FcsUploadDate = DateTime.Now.Date.ToString("MM-dd-yyyy-hh-mm"),
                    ResultFilePath = "",
                    ResultDate = DateTime.Now.Date,
                    Delta = 0.00
                };

                storedPatient.Analyses.Add(analysis);
                user.Analyses.Add(analysis);
                _context.SaveChanges();

                if (!string.IsNullOrWhiteSpace(user.Phone))
                {
                    //send message to the user
                    _smsSender.SendSms(new AuthMessageSender.Message
                    {
                        Body = "Greetings" + "\nStatus on: " + model.OriginalFileName + "\n" + message
                    }, _sid, _authToken, _number, user.Phone);
                }

                model.UploadStatusMessage = message;
            }
            catch (StorageException e)
            {
                model.UploadStatusMessage = "Failed to Upload file. Exception - " + e.Message;
                errorInOperation = true;
            }
            finally
            {
                HttpContext.Session.Remove("CurrentFile");
            }
            return Json(new
            {
                error = errorInOperation,
                isLastBlock = model.IsUploadCompleted,
                message = model.UploadStatusMessage
            });
        }