C# ICloudBlob.RenewLeaseAsync方法代码示例

 /// <summary>
 /// Puts the lease on the given blob in a renewed state.
 /// </summary>
 /// <param name="blob">The blob with the lease.</param>
 /// <param name="leaseTime">The amount of time on the renewed lease.</param>
 /// <returns>The lease ID of the current lease.</returns>
 internal static async Task<string> SetRenewedStateAsync(ICloudBlob blob, TimeSpan? leaseTime)
 {
     string leaseId = await SetLeasedStateAsync(blob, leaseTime);
     await blob.RenewLeaseAsync(AccessCondition.GenerateLeaseCondition(leaseId));
     return leaseId;
 }

        private async Task<Tuple<IDisposable, string>> LockInternal(ICloudBlob blob)
        {
            string leaseId;

            try
            {
                leaseId = await blob.AcquireLeaseAsync(TimeSpan.FromMinutes(1), null).ConfigureAwait(false);
                LeoTrace.WriteLine("Leased Blob: " + blob.Name);
            }
            catch (StorageException e)
            {
                // If we have a conflict this blob is already locked...
                if (e.RequestInformation.HttpStatusCode == 409)
                {
                    return null;
                }

                if (e.RequestInformation.HttpStatusCode == 404)
                {
                    leaseId = null;
                }
                else
                {
                    throw e.Wrap(blob.Name);
                }
            }

            // May not have had a blob pushed...
            if (leaseId == null)
            {
                try
                {
                    using (var stream = new MemoryStream(new byte[1]))
                    {
                        try
                        {
                            await blob.UploadFromStreamAsync(stream).ConfigureAwait(false);
                        }
                        catch (StorageException) { }  // Just eat storage exceptions at this point... something was created obviously
                    }
                    leaseId = await blob.AcquireLeaseAsync(TimeSpan.FromMinutes(1), null).ConfigureAwait(false);
                    LeoTrace.WriteLine("Created new blob and lease (2 calls): " + blob.Name);
                }
                catch (StorageException e)
                {
                    // If we have a conflict this blob is already locked...
                    if (e.RequestInformation.HttpStatusCode == 409)
                    {
                        return null;
                    }

                    if (e.RequestInformation.HttpStatusCode == 404)
                    {
                        leaseId = null;
                    }
                    else
                    {
                        throw e.Wrap(blob.Name);
                    }
                }
            }

            var condition = AccessCondition.GenerateLeaseCondition(leaseId);

            // Every 30 secs keep the lock renewed
            var keepAlive = AsyncEnumerableEx.CreateTimer(TimeSpan.FromSeconds(30))
                .Select(t =>
                {
                    LeoTrace.WriteLine("Renewed Lease: " + blob.Name);
                    return blob.RenewLeaseAsync(condition);
                })
                .Unwrap()
                .TakeUntilDisposed(null, t =>
                {
                    try
                    {
                        blob.ReleaseLease(condition);
                    }
                    catch (Exception e)
                    {
                        LeoTrace.WriteLine("Release failed: " + e.Message);
                    }
                });


            return Tuple.Create((IDisposable)keepAlive, leaseId);
        }

 private Thread StartNewAutoRenewLeaseThread(ICloudBlob blob, string leaseId, CancellationToken cancellationToken)
 {
     var autoRenewLeaseThread = new Thread(
         async () =>
         {
             System.Diagnostics.Trace.TraceInformation("Thread [{0}] started.", Thread.CurrentThread.ManagedThreadId);
             var blobUriString = blob.Uri.ToString();
             try
             {
                 while (!cancellationToken.IsCancellationRequested &&
                        await blob.ExistsAsync(cancellationToken))
                 {
                     // auto-renew lease when about to expire
                     Thread.Sleep(_leaseExpirationThreshold);
                     System.Diagnostics.Trace.TraceInformation("Thread [{0}] working.",
                         Thread.CurrentThread.ManagedThreadId);
                     _jobEventSource.BeginningRenewLease(blobUriString);
                     await blob.RenewLeaseAsync(AccessCondition.GenerateLeaseCondition(leaseId), cancellationToken);
                     _jobEventSource.FinishedRenewLease(blobUriString);
                 }
             }
             catch (TaskCanceledException)
             {
                 System.Diagnostics.Trace.TraceWarning("Thread [{0}] cancelled.", Thread.CurrentThread.ManagedThreadId);
                 // No need to track
             }
             catch
             {
                 System.Diagnostics.Trace.TraceError("Thread [{0}] error.", Thread.CurrentThread.ManagedThreadId);
                 // The blob could have been deleted in the meantime and this thread will be killed either way.
                 // No need to track in Application Insights.
             }
         });
     autoRenewLeaseThread.Start();
     return autoRenewLeaseThread;
 }

 private static async Task RenewLease(ICloudBlob blob, string leaseId)
 {
     var blobKey = GetKey(blob);
     try
     {
         await blob.RenewLeaseAsync(
             new AccessCondition
             {
                 LeaseId = leaseId
             });
         Trace.TraceInformation("Renewed lease for blob {0}", blobKey);
     }
     catch (Exception ex)
     {
         Trace.TraceError("Failed to renew lease for blob {0}. Exception was: {1}", blobKey, ex);
     }
 }