protected IteratorAsyncResult(TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
this.timeoutHelper = new Microsoft.ServiceBus.Common.TimeoutHelper(timeout, true);
IteratorAsyncResult <TIteratorAsyncResult> iteratorAsyncResult = this;
iteratorAsyncResult.OnCompleting = (Action <AsyncResult, Exception>)Delegate.Combine(iteratorAsyncResult.OnCompleting, IteratorAsyncResult <TIteratorAsyncResult> .onFinally);
}
private static void Finally(AsyncResult result, Exception exception)
{
IteratorAsyncResult <TIteratorAsyncResult> iteratorAsyncResult = (IteratorAsyncResult <TIteratorAsyncResult>)result;
try
{
IEnumerator <IteratorAsyncResult <TIteratorAsyncResult> .AsyncStep> enumerator = iteratorAsyncResult.steps;
if (enumerator != null)
{
enumerator.Dispose();
}
}
catch (Exception exception2)
{
Exception exception1 = exception2;
if (Fx.IsFatal(exception1))
{
throw;
}
MessagingClientEtwProvider.Provider.EventWriteExceptionAsWarning(exception1.ToStringSlim());
if (exception == null)
{
throw;
}
}
}
public AsyncStep(Transaction transaction, IteratorAsyncResult <TIteratorAsyncResult> .BeginCall beginCall, IteratorAsyncResult <TIteratorAsyncResult> .EndCall endCall, IteratorAsyncResult <TIteratorAsyncResult> .Call call, IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy policy)
{
this.transaction = transaction;
this.policy = policy;
this.beginCall = beginCall;
this.endCall = endCall;
this.call = call;
}
protected override IEnumerator <IteratorAsyncResult <OpenCollectionIteratedAsyncResult> .AsyncStep> GetAsyncSteps()
{
foreach (ICommunicationObject communicationObject in this.CommunicationObjects)
{
this.currentCommunicationObject = communicationObject;
OpenCollectionIteratedAsyncResult openCollectionIteratedAsyncResult = this;
IteratorAsyncResult <OpenCollectionIteratedAsyncResult> .BeginCall beginCall = (OpenCollectionIteratedAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.currentCommunicationObject.BeginOpen(t, c, s);
IteratorAsyncResult <OpenCollectionIteratedAsyncResult> .EndCall endCall = (OpenCollectionIteratedAsyncResult thisPtr, IAsyncResult r) => thisPtr.currentCommunicationObject.EndOpen(r);
yield return(openCollectionIteratedAsyncResult.CallAsync(beginCall, endCall, (OpenCollectionIteratedAsyncResult thisPtr, TimeSpan t) => thisPtr.currentCommunicationObject.Open(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
}
public static new void End(IAsyncResult result)
{
IteratorAsyncResult <TIteratorAsyncResult> .SleepAsyncResult sleepAsyncResult = AsyncResult <IteratorAsyncResult <TIteratorAsyncResult> .SleepAsyncResult> .End(result);
try
{
sleepAsyncResult.cancellationTokenRegistration.Dispose();
}
catch (ObjectDisposedException objectDisposedException)
{
}
}
protected override IEnumerator <IteratorAsyncResult <CloseCollectionIteratedAsyncResult> .AsyncStep> GetAsyncSteps()
{
foreach (ICommunicationObject communicationObject in this.CommunicationObjects)
{
if (communicationObject == null || communicationObject.State == CommunicationState.Closed)
{
continue;
}
this.currentCommunicationObject = communicationObject;
CloseCollectionIteratedAsyncResult closeCollectionIteratedAsyncResult = this;
IteratorAsyncResult <CloseCollectionIteratedAsyncResult> .BeginCall beginCall = (CloseCollectionIteratedAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.currentCommunicationObject.BeginClose(t, c, s);
IteratorAsyncResult <CloseCollectionIteratedAsyncResult> .EndCall endCall = (CloseCollectionIteratedAsyncResult thisPtr, IAsyncResult r) => thisPtr.currentCommunicationObject.EndClose(r);
yield return(closeCollectionIteratedAsyncResult.CallAsync(beginCall, endCall, (CloseCollectionIteratedAsyncResult thisPtr, TimeSpan t) => thisPtr.currentCommunicationObject.Close(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
continue;
}
this.currentCommunicationObject.Abort();
}
}
private static bool StepCallback(IAsyncResult result)
{
IteratorAsyncResult <TIteratorAsyncResult> asyncState = (IteratorAsyncResult <TIteratorAsyncResult>)result.AsyncState;
bool flag = asyncState.CheckSyncContinue(result);
if (!flag)
{
asyncState.everCompletedAsynchronously = true;
try
{
asyncState.steps.Current.EndCall((TIteratorAsyncResult)asyncState, result);
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception) || !asyncState.HandleException(exception))
{
throw;
}
}
asyncState.EnumerateSteps(IteratorAsyncResult <TIteratorAsyncResult> .CurrentThreadType.Callback);
}
return(flag);
}
public ParallelAsyncResult(TIteratorAsyncResult iteratorAsyncResult, ICollection <TWorkItem> workItems, IteratorAsyncResult <TIteratorAsyncResult> .BeginCall <TWorkItem> beginCall, IteratorAsyncResult <TIteratorAsyncResult> .EndCall <TWorkItem> endCall, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
this.iteratorAsyncResult = iteratorAsyncResult;
this.workItems = workItems;
this.endCall = endCall;
this.actions = (long)(this.workItems.Count + 1);
foreach (TWorkItem workItem in workItems)
{
try
{
beginCall(iteratorAsyncResult, workItem, timeout, IteratorAsyncResult <TIteratorAsyncResult> .ParallelAsyncResult <TWorkItem> .completed, new IteratorAsyncResult <TIteratorAsyncResult> .ParallelAsyncResult <TWorkItem> .CallbackState(this, workItem));
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception))
{
throw;
}
this.TryComplete(exception, true);
}
}
this.TryComplete(null, true);
}
protected override IEnumerator <IteratorAsyncResult <SendAvailabilityPairedNamespaceOptions.CloseAsyncResult> .AsyncStep> GetAsyncSteps()
{
if (this.options.availabilityTimers.Count > 0)
{
foreach (IOThreadTimer value in this.options.availabilityTimers.Values)
{
value.Cancel();
}
}
if (this.options.EnableSyphon)
{
SendAvailabilityPairedNamespaceOptions.CloseAsyncResult closeAsyncResult = this;
IteratorAsyncResult <SendAvailabilityPairedNamespaceOptions.CloseAsyncResult> .BeginCall beginCall = (SendAvailabilityPairedNamespaceOptions.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.options.pump.BeginClose(t, c, s);
yield return(closeAsyncResult.CallAsync(beginCall, (SendAvailabilityPairedNamespaceOptions.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.options.pump.EndClose(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
SendAvailabilityPairedNamespaceOptions.CloseAsyncResult closeAsyncResult1 = this;
IteratorAsyncResult <SendAvailabilityPairedNamespaceOptions.CloseAsyncResult> .BeginCall beginCall1 = (SendAvailabilityPairedNamespaceOptions.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.options.SecondaryMessagingFactory.BeginClose(t, c, s);
yield return(closeAsyncResult1.CallAsync(beginCall1, (SendAvailabilityPairedNamespaceOptions.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.options.SecondaryMessagingFactory.EndClose(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null)
{
this.options.SecondaryMessagingFactory.Abort();
}
}
}
protected override IEnumerator <IteratorAsyncResult <EventHubClient.CloseOrAbortAsyncResult> .AsyncStep> GetAsyncSteps()
{
if (!this.shouldAbort)
{
EventHubClient.CloseOrAbortAsyncResult closeOrAbortAsyncResult = this;
IteratorAsyncResult <EventHubClient.CloseOrAbortAsyncResult> .BeginCall beginCall = (EventHubClient.CloseOrAbortAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.ClientEntityManager.BeginClose(t, c, s);
yield return(closeOrAbortAsyncResult.CallAsync(beginCall, (EventHubClient.CloseOrAbortAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.ClientEntityManager.EndClose(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
else
{
this.owner.ClientEntityManager.Abort();
}
}
protected override IEnumerator <IteratorAsyncResult <MessageSession.RetrySessionAsyncResult> .AsyncStep> GetAsyncSteps()
{
TimeSpan timeSpan;
bool flag;
bool flag1;
int num = 0;
timeSpan = (this.session.RetryPolicy.IsServerBusy ? Microsoft.ServiceBus.RetryPolicy.ServerBusyBaseSleepTime : TimeSpan.Zero);
TimeSpan zero = timeSpan;
if (!this.session.RetryPolicy.IsServerBusy || !(Microsoft.ServiceBus.RetryPolicy.ServerBusyBaseSleepTime >= base.OriginalTimeout))
{
do
{
flag1 = false;
if (zero != TimeSpan.Zero)
{
yield return(base.CallAsyncSleep(zero));
}
switch (this.operation)
{
case MessageSession.SessionOperation.GetState:
{
MessageSession.RetrySessionAsyncResult retrySessionAsyncResult = this;
Transaction ambientTransaction = base.AmbientTransaction;
IteratorAsyncResult <MessageSession.RetrySessionAsyncResult> .BeginCall beginCall = (MessageSession.RetrySessionAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.session.OnBeginGetState(thisPtr.trackingContext, t, c, s);
yield return(retrySessionAsyncResult.CallTransactionalAsync(ambientTransaction, beginCall, (MessageSession.RetrySessionAsyncResult thisPtr, IAsyncResult r) => thisPtr.SessionState = thisPtr.session.OnEndGetState(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
break;
}
case MessageSession.SessionOperation.SetState:
{
if (this.stream != null && this.stream.CanSeek && this.stream.Position != (long)0)
{
this.stream.Position = (long)0;
}
MessageSession.RetrySessionAsyncResult retrySessionAsyncResult1 = this;
Transaction transaction = base.AmbientTransaction;
IteratorAsyncResult <MessageSession.RetrySessionAsyncResult> .BeginCall beginCall1 = (MessageSession.RetrySessionAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.session.OnBeginSetState(thisPtr.trackingContext, thisPtr.stream, t, c, s);
yield return(retrySessionAsyncResult1.CallTransactionalAsync(transaction, beginCall1, (MessageSession.RetrySessionAsyncResult thisPtr, IAsyncResult r) => thisPtr.session.OnEndSetState(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
break;
}
case MessageSession.SessionOperation.RenewSessionLock:
{
MessageSession.RetrySessionAsyncResult retrySessionAsyncResult2 = this;
IteratorAsyncResult <MessageSession.RetrySessionAsyncResult> .BeginCall beginCall2 = (MessageSession.RetrySessionAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.session.OnBeginRenewLock(thisPtr.trackingContext, t, c, s);
yield return(retrySessionAsyncResult2.CallAsync(beginCall2, (MessageSession.RetrySessionAsyncResult thisPtr, IAsyncResult r) => thisPtr.LockedUntilUtcTime = thisPtr.session.OnEndRenewLock(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
break;
}
}
if (base.LastAsyncStepException == null)
{
this.session.RetryPolicy.ResetServerBusy();
}
else
{
base.LastAsyncStepException = this.session.ProcessException(base.LastAsyncStepException);
MessagingPerformanceCounters.IncrementExceptionPerSec(this.session.MessagingFactory.Address, 1, base.LastAsyncStepException);
flag = (base.TransactionExists ? false : this.session.RetryPolicy.ShouldRetry(base.RemainingTime(), num, base.LastAsyncStepException, out zero));
flag1 = flag;
if (this.operation == MessageSession.SessionOperation.SetState && this.stream != null && !this.stream.CanSeek)
{
flag1 = false;
zero = TimeSpan.Zero;
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteRetryPolicyStreamNotSeekable(this.trackingContext.Activity, this.trackingContext.TrackingId, this.session.RetryPolicy.GetType().Name, this.operation.ToString()));
}
if (!flag1)
{
continue;
}
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteRetryPolicyIteration(this.trackingContext.Activity, this.trackingContext.TrackingId, this.session.RetryPolicy.GetType().Name, this.operation.ToString(), num, zero.ToString(), this.LastAsyncStepException.GetType().FullName, this.LastAsyncStepException.Message));
num++;
}
}while (flag1);
base.Complete(base.LastAsyncStepException);
}
else
{
string str = this.session.RetryPolicy.ServerBusyExceptionMessage;
yield return(base.CallAsyncSleep(base.RemainingTime()));
base.Complete(new ServerBusyException(str, this.trackingContext));
}
}
protected override IEnumerator <IteratorAsyncResult <MessageReceivePump.StartAsyncResult> .AsyncStep> GetAsyncSteps()
{
TimeSpan timeSpan;
while (this.currentRetryCount <= 3)
{
MessageReceivePump.StartAsyncResult startAsyncResult = this;
startAsyncResult.currentRetryCount = startAsyncResult.currentRetryCount + 1;
MessageReceivePump.StartAsyncResult startAsyncResult1 = this;
IteratorAsyncResult <MessageReceivePump.StartAsyncResult> .BeginCall beginCall = (MessageReceivePump.StartAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.receiver.BeginReceive(TimeSpan.Zero, c, s);
yield return(startAsyncResult1.CallAsync(beginCall, (MessageReceivePump.StartAsyncResult thisPtr, IAsyncResult r) => thisPtr.InitialMessage = thisPtr.owner.receiver.EndReceive(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
break;
}
if (this.ShouldRetry(base.LastAsyncStepException))
{
if (!MessageReceivePump.ShouldBackoff(base.LastAsyncStepException, out timeSpan))
{
continue;
}
yield return(base.CallAsyncSleep(timeSpan));
}
else
{
base.Complete(base.LastAsyncStepException);
goto Label0;
}
}
try
{
(new MessageReceivePump.PumpAsyncResult(this.owner, this.InitialMessage, this.onPumpCompleted, this)).Start();
}
catch (Exception exception)
{
Environment.FailFast(exception.ToString());
}
Label0:
yield break;
}
protected override IEnumerator <IteratorAsyncResult <SendAvailabilityPairedNamespaceMessageSender.OpenAsyncResult> .AsyncStep> GetAsyncSteps()
{
SendAvailabilityPairedNamespaceMessageSender.OpenAsyncResult openAsyncResult = this;
IteratorAsyncResult <SendAvailabilityPairedNamespaceMessageSender.OpenAsyncResult> .BeginCall beginCall = (SendAvailabilityPairedNamespaceMessageSender.OpenAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.sender.BeginOpen(t, c, s);
yield return(openAsyncResult.CallAsync(beginCall, (SendAvailabilityPairedNamespaceMessageSender.OpenAsyncResult thisPtr, IAsyncResult r) => thisPtr.sender.EndOpen(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
protected override IEnumerator <IteratorAsyncResult <EventProcessorLifecycleManager.EventDataPumpAsyncResult> .AsyncStep> GetAsyncSteps()
{
TimeSpan timeSpan;
while (this.lifeCycleManager.isStarted == 1 && this.receiver.IsOpened)
{
this.messages = null;
EventProcessorLifecycleManager.EventDataPumpAsyncResult eventDataPumpAsyncResult = this;
yield return(eventDataPumpAsyncResult.CallTask((EventProcessorLifecycleManager.EventDataPumpAsyncResult thisPtr, TimeSpan t) => this.receiver.ReceiveAsync(this.lifeCycleManager.processorOptions.MaxBatchSize, this.lifeCycleManager.processorOptions.ReceiveTimeOut).Then <IEnumerable <EventData>, object>((IEnumerable <EventData> m) => {
if (m != null && m.Any <EventData>())
{
this.messages = m;
}
return TaskHelpers.GetCompletedTask <object>(null);
}), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpReceiveException(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, base.LastAsyncStepException.ToString()));
this.lifeCycleManager.RaiseExceptionReceivedEvent(base.LastAsyncStepException, "Receive");
if (base.LastAsyncStepException is ReceiverDisconnectedException)
{
if (Interlocked.CompareExchange(ref this.lifeCycleManager.isStarted, 0, 1) != 1)
{
continue;
}
EventProcessorLifecycleManager.EventDataPumpAsyncResult eventDataPumpAsyncResult1 = this;
IteratorAsyncResult <EventProcessorLifecycleManager.EventDataPumpAsyncResult> .BeginCall beginCall = (EventProcessorLifecycleManager.EventDataPumpAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => EventProcessorLifecycleManager.EventProcessorShutdownAsyncResult.Begin(thisPtr.lifeCycleManager, thisPtr.receiver, thisPtr.lifeCycleManager.processor, thisPtr.context, CloseReason.LeaseLost, null, c, s);
yield return(eventDataPumpAsyncResult1.CallAsync(beginCall, (EventProcessorLifecycleManager.EventDataPumpAsyncResult thisPtr, IAsyncResult r) => AsyncResult <EventProcessorLifecycleManager.EventProcessorShutdownAsyncResult> .End(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
continue;
}
else if (EventProcessorLifecycleManager.EventDataPumpAsyncResult.ShouldBackoff(base.LastAsyncStepException, out timeSpan))
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpBackoff(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, (int)EventProcessorLifecycleManager.ServerBusyExceptionBackoffAmount.TotalMilliseconds, base.LastAsyncStepException.ToString()));
yield return(base.CallAsyncSleep(timeSpan));
}
}
if (this.messages == null || !this.messages.Any <EventData>())
{
continue;
}
EventProcessorLifecycleManager.EventDataPumpAsyncResult eventDataPumpAsyncResult2 = this;
yield return(eventDataPumpAsyncResult2.CallTask((EventProcessorLifecycleManager.EventDataPumpAsyncResult thisPtr, TimeSpan t) => {
if (this.messages == null || !this.messages.Any <EventData>())
{
return TaskHelpers.GetCompletedTask <object>(null);
}
EventData eventDatum = this.messages.Last <EventData>();
if (eventDatum != null)
{
this.context.Offset = eventDatum.Offset;
this.context.SequenceNumber = eventDatum.SequenceNumber;
}
return this.lifeCycleManager.processor.ProcessEventsAsync(this.context, this.messages);
}, IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
continue;
}
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpUserCallbackException(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, base.LastAsyncStepException.ToString()));
this.lifeCycleManager.RaiseExceptionReceivedEvent(base.LastAsyncStepException, "ProcessMessages");
if (!(base.LastAsyncStepException is LeaseLostException))
{
continue;
}
bool flag = true;
try
{
AggregateException lastAsyncStepException = base.LastAsyncStepException as AggregateException;
if (lastAsyncStepException != null)
{
AggregateException aggregateException = lastAsyncStepException;
aggregateException.Handle((Exception e) => e is LeaseLostException);
}
}
catch
{
flag = false;
}
if (!flag || Interlocked.CompareExchange(ref this.lifeCycleManager.isStarted, 0, 1) != 1)
{
continue;
}
EventProcessorLifecycleManager.EventDataPumpAsyncResult eventDataPumpAsyncResult3 = this;
IteratorAsyncResult <EventProcessorLifecycleManager.EventDataPumpAsyncResult> .BeginCall beginCall1 = (EventProcessorLifecycleManager.EventDataPumpAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => EventProcessorLifecycleManager.EventProcessorShutdownAsyncResult.Begin(thisPtr.lifeCycleManager, thisPtr.receiver, thisPtr.lifeCycleManager.processor, thisPtr.context, CloseReason.LeaseLost, null, c, s);
yield return(eventDataPumpAsyncResult3.CallAsync(beginCall1, (EventProcessorLifecycleManager.EventDataPumpAsyncResult thisPtr, IAsyncResult r) => AsyncResult <EventProcessorLifecycleManager.EventProcessorShutdownAsyncResult> .End(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
}
}
protected override IEnumerator <IteratorAsyncResult <EventHubConsumerGroup.CloseOrAbortAsyncResult> .AsyncStep> GetAsyncSteps()
{
foreach (EventProcessorLifecycleManager value in this.owner.handlers.Values)
{
EventHubConsumerGroup.CloseOrAbortAsyncResult closeOrAbortAsyncResult = this;
yield return(closeOrAbortAsyncResult.CallTask((EventHubConsumerGroup.CloseOrAbortAsyncResult AsyncResult, TimeSpan timespan) => value.UnregisterProcessorAsync(CloseReason.Shutdown), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
this.owner.handlers.Clear();
if (!this.shouldAbort)
{
EventHubConsumerGroup.CloseOrAbortAsyncResult closeOrAbortAsyncResult1 = this;
IteratorAsyncResult <EventHubConsumerGroup.CloseOrAbortAsyncResult> .BeginCall beginCall = (EventHubConsumerGroup.CloseOrAbortAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.ClientEntityManager.BeginClose(t, c, s);
yield return(closeOrAbortAsyncResult1.CallAsync(beginCall, (EventHubConsumerGroup.CloseOrAbortAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.ClientEntityManager.EndClose(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
else
{
this.owner.ClientEntityManager.Abort();
}
}
protected override IEnumerator <IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult> .AsyncStep> GetAsyncSteps()
{
while (true)
{
Monitor.Enter(this.owner.ThisLock);
this.shouldReleaseLock = true;
try
{
this.owner.ThrowIfDisposedOrNotOpen();
if (!this.owner.instances.TryGetValue(this.key, out this.singletonContext))
{
this.singletonContext = new SingletonDictionaryManager <TKey, TInstance> .SingletonContext(SingletonDictionaryManager <TKey, TInstance> .SingletonState.Loading);
this.owner.instances.Add(this.key, this.singletonContext);
this.ownsLoading = true;
break;
}
else if (this.singletonContext.State == SingletonDictionaryManager <TKey, TInstance> .SingletonState.Loaded)
{
this.Instance = this.singletonContext.Instance;
break;
}
else if (base.RemainingTime() <= TimeSpan.Zero)
{
base.Complete(new TimeoutException(SRCore.TimeoutOnOperation(base.OriginalTimeout)));
goto Label0;
}
else if (this.singletonContext.State == SingletonDictionaryManager <TKey, TInstance> .SingletonState.Loading || this.singletonContext.State == SingletonDictionaryManager <TKey, TInstance> .SingletonState.Unloading)
{
SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult loadInstanceAsyncResult = this;
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult> .BeginCall beginCall = (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => {
IAsyncResult asyncResult;
try
{
thisPtr.shouldReleaseLock = false;
asyncResult = thisPtr.owner.BeginWaitPendingOperation(thisPtr.key, t, c, s);
}
finally
{
Monitor.Exit(thisPtr.owner.ThisLock);
}
return(asyncResult);
};
yield return(loadInstanceAsyncResult.CallAsync(beginCall, (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.EndWaitPendingOperation(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
else
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] state = new object[] { this.singletonContext.State, typeof(SingletonDictionaryManager <TKey, TInstance>).Name };
string str = string.Format(invariantCulture, "{0} was not recognized. This is likely a bug in {1}.", state);
Fx.AssertAndFailFastService(str);
break;
}
}
finally
{
if (this.shouldReleaseLock)
{
Monitor.Exit(this.owner.ThisLock);
}
}
}
if (!this.ownsLoading)
{
this.owner.OnGetInstance(this.singletonContext, this.key, this.singletonContext.Instance, this.loadingContext);
}
else
{
SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult loadInstanceAsyncResult1 = this;
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult> .BeginCall beginCall1 = (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.OnBeginCreateInstance(thisPtr.singletonContext, thisPtr.key, thisPtr.loadingContext, t, c, s);
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult> .EndCall instance = (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.singletonContext.Instance = thisPtr.owner.OnEndCreateInstance(r);
yield return(loadInstanceAsyncResult1.CallAsync(beginCall1, instance, (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, TimeSpan t) => thisPtr.singletonContext.Instance = thisPtr.owner.OnCreateInstance(thisPtr.singletonContext, thisPtr.key, thisPtr.loadingContext, t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
this.created = true;
SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult loadInstanceAsyncResult2 = this;
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult> .BeginCall beginCall2 = (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.OnBeginOpenInstance(thisPtr.singletonContext, thisPtr.key, thisPtr.singletonContext.Instance, t, c, s);
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult> .EndCall endCall = (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.OnEndOpenInstance(r);
yield return(loadInstanceAsyncResult2.CallAsync(beginCall2, endCall, (SingletonDictionaryManager <TKey, TInstance> .LoadInstanceAsyncResult thisPtr, TimeSpan t) => thisPtr.owner.OnOpenInstance(thisPtr.singletonContext, thisPtr.key, thisPtr.singletonContext.Instance, t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
Label0:
yield break;
}
protected override IEnumerator <IteratorAsyncResult <MessageSessionPumpHost.CloseOrAbortAsyncResult> .AsyncStep> GetAsyncSteps()
{
object obj = null;
bool flag = false;
try
{
object thisLock = base.ThisLock;
object obj1 = thisLock;
obj = thisLock;
Monitor.Enter(obj1, ref flag);
this.owner.markedForClosed = true;
this.pumpToClose = this.owner.pump;
}
finally
{
if (flag)
{
Monitor.Exit(obj);
}
}
if (this.pumpToClose != null)
{
if (!this.shouldAbort)
{
MessageSessionPumpHost.CloseOrAbortAsyncResult closeOrAbortAsyncResult = this;
IteratorAsyncResult <MessageSessionPumpHost.CloseOrAbortAsyncResult> .BeginCall beginCall = (MessageSessionPumpHost.CloseOrAbortAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.pumpToClose.BeginClose(t, c, s);
IteratorAsyncResult <MessageSessionPumpHost.CloseOrAbortAsyncResult> .EndCall endCall = (MessageSessionPumpHost.CloseOrAbortAsyncResult thisPtr, IAsyncResult r) => thisPtr.pumpToClose.EndClose(r);
yield return(closeOrAbortAsyncResult.CallAsync(beginCall, endCall, (MessageSessionPumpHost.CloseOrAbortAsyncResult thisPtr, TimeSpan t) => thisPtr.pumpToClose.Close(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
else
{
this.pumpToClose.Abort();
}
}
}
protected override IEnumerator <IteratorAsyncResult <MessageBrowser.RetryBrowserAsyncResult> .AsyncStep> GetAsyncSteps()
{
TimeSpan timeSpan;
bool flag;
bool flag1;
int num = 0;
timeSpan = (this.browser.RetryPolicy.IsServerBusy ? Microsoft.ServiceBus.RetryPolicy.ServerBusyBaseSleepTime : TimeSpan.Zero);
TimeSpan timeSpan1 = timeSpan;
if (!this.browser.RetryPolicy.IsServerBusy || !(Microsoft.ServiceBus.RetryPolicy.ServerBusyBaseSleepTime >= base.OriginalTimeout))
{
do
{
flag1 = false;
if (timeSpan1 != TimeSpan.Zero)
{
yield return(base.CallAsyncSleep(timeSpan1));
}
MessageBrowser.RetryBrowserAsyncResult retryBrowserAsyncResult = this;
IteratorAsyncResult <MessageBrowser.RetryBrowserAsyncResult> .BeginCall beginCall = (MessageBrowser.RetryBrowserAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.browser.OnBeginPeek(thisPtr.trackingContext, thisPtr.fromSequenceNumber, thisPtr.messageCount, t, c, s);
yield return(retryBrowserAsyncResult.CallAsync(beginCall, (MessageBrowser.RetryBrowserAsyncResult thisPtr, IAsyncResult r) => thisPtr.Messages = thisPtr.browser.OnEndPeek(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
this.browser.RetryPolicy.ResetServerBusy();
}
else
{
MessagingPerformanceCounters.IncrementExceptionPerSec(this.browser.MessagingFactory.Address, 1, base.LastAsyncStepException);
flag = (base.TransactionExists ? false : this.browser.RetryPolicy.ShouldRetry(base.RemainingTime(), num, base.LastAsyncStepException, out timeSpan1));
flag1 = flag;
if (!flag1)
{
continue;
}
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteRetryPolicyIteration(this.trackingContext.Activity, this.trackingContext.TrackingId, this.browser.RetryPolicy.GetType().Name, "Peek", num, timeSpan1.ToString(), this.LastAsyncStepException.GetType().FullName, this.LastAsyncStepException.Message));
num++;
}
}while (flag1);
base.Complete(base.LastAsyncStepException);
}
else
{
string str = this.browser.RetryPolicy.ServerBusyExceptionMessage;
yield return(base.CallAsyncSleep(base.RemainingTime()));
base.Complete(new ServerBusyException(str, this.trackingContext));
}
}
protected override IEnumerator <IteratorAsyncResult <SendAvailabilityMessagePump.SendAsyncResult> .AsyncStep> GetAsyncSteps()
{
using (BrokeredMessage brokeredMessage = SendAvailabilityPairedNamespaceMessageSender.ConvertMessageForPrimary(this.message, this.messageSender.Path))
{
if (brokeredMessage == null || !this.pump.CanPump())
{
}
else
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceSendingMessage(this.sequenceNumber, this.messageSender.Path));
SendAvailabilityMessagePump.SendAsyncResult sendAsyncResult = this;
IteratorAsyncResult <SendAvailabilityMessagePump.SendAsyncResult> .BeginCall beginCall = (SendAvailabilityMessagePump.SendAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.messageSender.BeginSend(brokeredMessage, t, c, s);
yield return(sendAsyncResult.CallAsync(beginCall, (SendAvailabilityMessagePump.SendAsyncResult thisPtr, IAsyncResult r) => thisPtr.messageSender.EndSend(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceDestinationSendException(this.pump.options.PrimaryMessagingFactory.Address.ToString(), this.messageSender.Path, base.LastAsyncStepException));
MessagingException lastAsyncStepException = base.LastAsyncStepException as MessagingException;
if (lastAsyncStepException != null)
{
if (!lastAsyncStepException.IsTransient && !(lastAsyncStepException is QuotaExceededException))
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceDeadletterException(this.messageSender.MessagingFactory.Address.ToString(), this.messageSender.Path, lastAsyncStepException));
this.message.DeadLetter(SRClient.BacklogDeadletterReasonNotRetryable, SRClient.BacklogDeadletterDescriptionNotRetryable(this.messageSender.Path, lastAsyncStepException.GetType().Name, lastAsyncStepException.Message));
}
base.Complete(base.LastAsyncStepException);
}
else
{
base.Complete(base.LastAsyncStepException);
}
}
else
{
SendAvailabilityMessagePump.SendAsyncResult sendAsyncResult1 = this;
IteratorAsyncResult <SendAvailabilityMessagePump.SendAsyncResult> .BeginCall beginCall1 = (SendAvailabilityMessagePump.SendAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.message.BeginComplete(t, c, s);
yield return(sendAsyncResult1.CallAsync(beginCall1, (SendAvailabilityMessagePump.SendAsyncResult thisPtr, IAsyncResult r) => thisPtr.message.EndComplete(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
goto Label0;
}
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceDestinationSendException(this.pump.options.PrimaryMessagingFactory.Address.ToString(), this.messageSender.Path, base.LastAsyncStepException));
base.Complete(base.LastAsyncStepException);
}
}
}
Label0:
yield break;
}
protected override IEnumerator <IteratorAsyncResult <SendAvailabilityMessagePump.ProcessQueueAsyncResult> .AsyncStep> GetAsyncSteps()
{
object obj;
List <BrokeredMessage> brokeredMessages;
MessageSender retryPolicy;
bool flag = false;
HashSet <string> strs = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
do
{
if (base.RemainingTime() < SendAvailabilityMessagePump.ProcessQueueAsyncResult.MinTimeToProcessLoop)
{
break;
}
base.LastAsyncStepException = null;
IEnumerable <BrokeredMessage> brokeredMessages1 = null;
bool flag1 = false;
if (!this.pump.CanPump())
{
break;
}
SendAvailabilityMessagePump.ProcessQueueAsyncResult processQueueAsyncResult = this;
yield return(processQueueAsyncResult.CallAsync((SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.messageReceiver.BeginTryReceive(100, SendAvailabilityMessagePump.ProcessQueueAsyncResult.DefaultReadTimeout, c, s), (SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, IAsyncResult r) => flag1 = this.messageReceiver.EndTryReceive(r, out brokeredMessages1), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceMessagePumpReceiveFailed(this.messageReceiver.MessagingFactory.Address.ToString(), this.messageReceiver.Path, base.LastAsyncStepException));
if (!Fx.IsFatal(base.LastAsyncStepException) && !(base.LastAsyncStepException is UnauthorizedAccessException) && !(base.LastAsyncStepException is MessagingEntityNotFoundException))
{
break;
}
base.Complete(base.LastAsyncStepException);
break;
}
else if (!flag1 || brokeredMessages1 == null)
{
flag = true;
}
else
{
this.messagesToDispose.AddRange(brokeredMessages1);
Dictionary <string, List <BrokeredMessage> > strs1 = new Dictionary <string, List <BrokeredMessage> >();
foreach (BrokeredMessage brokeredMessage in brokeredMessages1)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceReceiveMessageFromSecondary(brokeredMessage.SequenceNumber, this.messageReceiver.Path));
base.LastAsyncStepException = null;
if (!brokeredMessage.Properties.TryGetValue("x-ms-path", out obj) || !(obj is string))
{
BrokeredMessage brokeredMessage1 = brokeredMessage;
string messageId = brokeredMessage.MessageId;
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceMessageNoPathInBacklog(this.messageReceiver.MessagingFactory.Address.ToString(), this.messageReceiver.Path, messageId));
yield return(base.CallAsync((SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => brokeredMessage1.BeginDeadLetter(SRClient.BacklogDeadletterReasonNoQueuePath, SRClient.BacklogDeadletterDescriptionNoQueuePath, c, s), (SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, IAsyncResult r) => brokeredMessage1.EndDeadLetter(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
}
else
{
string str = (string)obj;
if (!strs.Contains(str))
{
if (!strs1.TryGetValue(str, out brokeredMessages))
{
brokeredMessages = new List <BrokeredMessage>();
strs1.Add(str, brokeredMessages);
}
brokeredMessages.Add(brokeredMessage);
}
}
}
Dictionary <string, List <BrokeredMessage> > .KeyCollection.Enumerator enumerator = strs1.Keys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
string current = enumerator.Current;
base.LastAsyncStepException = null;
string str1 = current;
List <BrokeredMessage> item = strs1[current];
retryPolicy = null;
yield return(base.CallAsync((SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.pump.options.PrimaryMessagingFactory.BeginCreateMessageSender(null, str1, false, t, c, s), (SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, IAsyncResult r) => retryPolicy = thisPtr.pump.options.PrimaryMessagingFactory.EndCreateMessageSender(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
retryPolicy.ShouldLinkRetryPolicy = true;
retryPolicy.RetryPolicy = this.pump.options.PrimaryMessagingFactory.RetryPolicy;
if (!this.pump.CanPump())
{
goto Label1;
}
SendAvailabilityMessagePump.ProcessQueueAsyncResult processQueueAsyncResult1 = this;
List <BrokeredMessage> brokeredMessages2 = item;
IteratorAsyncResult <SendAvailabilityMessagePump.ProcessQueueAsyncResult> .BeginCall <BrokeredMessage> sendAsyncResult = (SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, BrokeredMessage i, TimeSpan t, AsyncCallback c, object s) => new SendAvailabilityMessagePump.SendAsyncResult(retryPolicy, i, this.pump, this.pump.options.PrimaryMessagingFactory.OperationTimeout, c, s);
yield return(processQueueAsyncResult1.CallParallelAsync <BrokeredMessage>(brokeredMessages2, sendAsyncResult, (SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, BrokeredMessage i, IAsyncResult r) => AsyncResult <SendAvailabilityMessagePump.SendAsyncResult> .End(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null && !strs.Contains(current))
{
strs.Add(current);
}
if (!retryPolicy.IsOpened)
{
continue;
}
SendAvailabilityMessagePump.ProcessQueueAsyncResult processQueueAsyncResult2 = this;
IteratorAsyncResult <SendAvailabilityMessagePump.ProcessQueueAsyncResult> .BeginCall beginCall = (SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => retryPolicy.BeginClose(thisPtr.RemainingTime(), c, s);
yield return(processQueueAsyncResult2.CallAsync(beginCall, (SendAvailabilityMessagePump.ProcessQueueAsyncResult thisPtr, IAsyncResult r) => retryPolicy.EndClose(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
continue;
}
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceMessagePumpProcessCloseSenderFailed(base.LastAsyncStepException));
}
else
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceCouldNotCreateMessageSender(this.messageReceiver.MessagingFactory.Address.ToString(), this.messageReceiver.Path, base.LastAsyncStepException));
}
}
goto Label0;
Label1:
retryPolicy.Abort();
break;
}
finally
{
((IDisposable)enumerator).Dispose();
}
}
Label0:
}while (!flag);
}
protected override IEnumerator <IteratorAsyncResult <MessageSessionPumpHost.RegisterSessionHandlerFactoryAsyncResult> .AsyncStep> GetAsyncSteps()
{
object obj = null;
bool flag = false;
try
{
object thisLock = this.owner.ThisLock;
object obj1 = thisLock;
obj = thisLock;
Monitor.Enter(obj1, ref flag);
if (this.owner.markedForClosed)
{
throw new OperationCanceledException(SRClient.MessageEntityDisposed);
}
if (this.owner.pump != null)
{
throw new InvalidOperationException(SRClient.SessionHandlerAlreadyRegistered);
}
this.ownsRegistration = true;
this.owner.pump = new MessageSessionPump(this.owner.entityName, this.owner.entity, this.factory, this.options);
}
finally
{
if (flag)
{
Monitor.Exit(obj);
}
}
MessageSessionPumpHost.RegisterSessionHandlerFactoryAsyncResult registerSessionHandlerFactoryAsyncResult = this;
IteratorAsyncResult <MessageSessionPumpHost.RegisterSessionHandlerFactoryAsyncResult> .BeginCall beginCall = (MessageSessionPumpHost.RegisterSessionHandlerFactoryAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.pump.BeginOpen(c, s);
yield return(registerSessionHandlerFactoryAsyncResult.CallAsync(beginCall, (MessageSessionPumpHost.RegisterSessionHandlerFactoryAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.pump.EndOpen(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
protected override IEnumerator <IteratorAsyncResult <SendAvailabilityPairedNamespaceOptions.StartAsyncResult> .AsyncStep> GetAsyncSteps()
{
TimeSpan timeSpan;
MessagingException lastAsyncStepException;
IEnumerable <QueueDescription> queueDescriptions = null;
Stopwatch stopwatch = Stopwatch.StartNew();
do
{
if (stopwatch.Elapsed >= SendAvailabilityPairedNamespaceOptions.StartAsyncResult.GetQueuesTime)
{
break;
}
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] sbNamespace = new object[] { this.options.SbNamespace };
string str = string.Format(invariantCulture, "startswith(path, '{0}/x-servicebus-transfer/') eq true", sbNamespace);
SendAvailabilityPairedNamespaceOptions.StartAsyncResult startAsyncResult = this;
IteratorAsyncResult <SendAvailabilityPairedNamespaceOptions.StartAsyncResult> .BeginCall beginCall = (SendAvailabilityPairedNamespaceOptions.StartAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.options.SecondaryNamespaceManager.BeginGetQueues(str, c, s);
yield return(startAsyncResult.CallAsync(beginCall, (SendAvailabilityPairedNamespaceOptions.StartAsyncResult thisPtr, IAsyncResult r) => queueDescriptions = thisPtr.options.SecondaryNamespaceManager.EndGetQueues(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null && queueDescriptions != null)
{
break;
}
lastAsyncStepException = base.LastAsyncStepException as MessagingException;
}while (lastAsyncStepException == null || lastAsyncStepException.IsTransient);
if (queueDescriptions != null || base.LastAsyncStepException == null)
{
HashSet <string> strs = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (QueueDescription queueDescription in queueDescriptions)
{
strs.Add(queueDescription.Path);
}
for (int num = 0; num < this.options.BacklogQueueCount; num++)
{
string str1 = this.options.CreateBacklogQueueName(num);
if (!strs.Contains(str1))
{
this.options.availableBacklogQueues.Add(string.Empty);
}
else
{
this.options.availableBacklogQueues.Add(str1);
}
}
for (int j1 = 0; j1 < this.options.BacklogQueueCount; j1++)
{
string str2 = this.options.CreateBacklogQueueName(j1);
if (string.IsNullOrWhiteSpace(this.options.availableBacklogQueues[j1]))
{
int num1 = 0;
while (num1 < 3)
{
if (base.LastAsyncStepException == null)
{
QueueDescription queueDescription1 = new QueueDescription(str2)
{
MaxSizeInMegabytes = (long)5120,
MaxDeliveryCount = 2147483647,
DefaultMessageTimeToLive = TimeSpan.MaxValue,
AutoDeleteOnIdle = TimeSpan.MaxValue
};
QueueDescription queueDescription2 = queueDescription1;
timeSpan = (Constants.MaximumLockDuration < SendAvailabilityPairedNamespaceOptions.StartAsyncResult.LocalMaxLockDuration ? Constants.MaximumLockDuration : SendAvailabilityPairedNamespaceOptions.StartAsyncResult.LocalMaxLockDuration);
queueDescription2.LockDuration = timeSpan;
queueDescription1.EnableDeadLetteringOnMessageExpiration = true;
queueDescription1.EnableBatchedOperations = true;
SendAvailabilityPairedNamespaceOptions.StartAsyncResult startAsyncResult1 = this;
IteratorAsyncResult <SendAvailabilityPairedNamespaceOptions.StartAsyncResult> .BeginCall beginCall1 = (SendAvailabilityPairedNamespaceOptions.StartAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.options.SecondaryNamespaceManager.BeginCreateQueue(queueDescription1, c, s);
yield return(startAsyncResult1.CallAsync(beginCall1, (SendAvailabilityPairedNamespaceOptions.StartAsyncResult thisPtr, IAsyncResult r) => thisPtr.options.SecondaryNamespaceManager.EndCreateQueue(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
}
if (base.LastAsyncStepException != null)
{
if (base.LastAsyncStepException is MessagingEntityAlreadyExistsException)
{
QueueDescription queueDescription3 = null;
SendAvailabilityPairedNamespaceOptions.StartAsyncResult startAsyncResult2 = this;
yield return(startAsyncResult2.CallAsync((SendAvailabilityPairedNamespaceOptions.StartAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.options.SecondaryNamespaceManager.BeginGetQueue(str2, c, s), (SendAvailabilityPairedNamespaceOptions.StartAsyncResult thisPtr, IAsyncResult r) => queueDescription3 = thisPtr.options.SecondaryNamespaceManager.EndGetQueue(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null && queueDescription3 != null && queueDescription3.Path == str2)
{
this.options.availableBacklogQueues[j1] = str2;
break;
}
}
if (!(base.LastAsyncStepException is UnauthorizedAccessException))
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceTransferQueueCreateError(str2, this.options.SecondaryNamespaceManager.Address.ToString(), this.LastAsyncStepException.ToString()));
yield return(base.CallAsyncSleep(SendAvailabilityPairedNamespaceOptions.StartAsyncResult.CreateQueuePauseTime));
num1++;
}
else
{
base.Complete(base.LastAsyncStepException);
goto Label0;
}
}
else
{
this.options.availableBacklogQueues[j1] = str2;
break;
}
}
}
}
for (int k = this.options.availableBacklogQueues.Count - 1; k >= 0; k--)
{
if (string.IsNullOrWhiteSpace(this.options.availableBacklogQueues[k]))
{
this.options.availableBacklogQueues.RemoveAt(k);
}
}
this.options.UpdateBacklogQueueCount(this.options.availableBacklogQueues.Count);
if (this.options.BacklogQueueCount == 0)
{
throw Fx.Exception.AsError(new SendAvailabilityBacklogException(SRClient.SendAvailabilityNoTransferQueuesCreated), null);
}
if (this.options.EnableSyphon)
{
this.options.pump = new SendAvailabilityMessagePump(this.options);
this.options.pump.Start();
}
}
else
{
base.Complete(base.LastAsyncStepException);
}
Label0:
yield break;
}
protected override IEnumerator <IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult> .AsyncStep> GetAsyncSteps()
{
while (true)
{
Monitor.Enter(this.owner.ThisLock);
this.shouldReleaseLock = true;
try
{
if (!this.owner.instances.TryGetValue(this.key, out this.singletonContext))
{
break;
}
if (this.singletonContext.State == SingletonDictionaryManager <TKey, TInstance> .SingletonState.Loaded)
{
this.singletonContext.State = SingletonDictionaryManager <TKey, TInstance> .SingletonState.Unloading;
this.instance = this.singletonContext.Instance;
this.ownsUnloading = true;
break;
}
else if (this.singletonContext.State == SingletonDictionaryManager <TKey, TInstance> .SingletonState.Loading || this.singletonContext.State == SingletonDictionaryManager <TKey, TInstance> .SingletonState.Unloading)
{
SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult unloadInstanceAsyncResult = this;
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult> .BeginCall beginCall = (SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => {
IAsyncResult asyncResult;
try
{
thisPtr.shouldReleaseLock = false;
asyncResult = thisPtr.owner.BeginWaitPendingOperation(thisPtr.key, t, c, s);
}
finally
{
Monitor.Exit(thisPtr.owner.ThisLock);
}
return(asyncResult);
};
yield return(unloadInstanceAsyncResult.CallAsync(beginCall, (SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.EndWaitPendingOperation(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
else
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] state = new object[] { this.singletonContext.State, typeof(SingletonDictionaryManager <TKey, TInstance>).Name };
string str = string.Format(invariantCulture, "{0} was not recognized. This is likely a bug in {1}.", state);
Fx.AssertAndFailFastService(str);
break;
}
}
finally
{
if (this.shouldReleaseLock)
{
Monitor.Exit(this.owner.ThisLock);
}
}
}
if (this.ownsUnloading)
{
if (!this.waitPendingOperationsCalled)
{
this.waitPendingOperationsCalled = true;
SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult unloadInstanceAsyncResult1 = this;
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult> .BeginCall beginCall1 = (SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.OnBeginWaitPendingOperations(thisPtr.instance, thisPtr.closeTimeout, c, s);
yield return(unloadInstanceAsyncResult1.CallAsync(beginCall1, (SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.OnEndWaitPendingOperations(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
if (!this.shouldAbort)
{
SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult unloadInstanceAsyncResult2 = this;
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult> .BeginCall beginCall2 = (SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.OnBeginCloseInstance(thisPtr.singletonContext, thisPtr.key, thisPtr.instance, thisPtr.unloadingContext, thisPtr.closeTimeout, c, s);
IteratorAsyncResult <SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult> .EndCall endCall = (SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.OnEndCloseInstance(r);
yield return(unloadInstanceAsyncResult2.CallAsync(beginCall2, endCall, (SingletonDictionaryManager <TKey, TInstance> .UnloadInstanceAsyncResult thisPtr, TimeSpan t) => thisPtr.owner.OnCloseInstance(thisPtr.singletonContext, thisPtr.key, thisPtr.instance, thisPtr.unloadingContext, thisPtr.closeTimeout), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
}
}
protected override IEnumerator <IteratorAsyncResult <MessageReceivePump.BatchCompleteAsyncResult> .AsyncStep> GetAsyncSteps()
{
List <Guid> guids = null;
yield return(base.CallAsyncSleep(MessageReceivePump.BatchCompleteAsyncResult.completionBufferWaitTime));
bool flag = false;
try
{
List <Guid> guids1 = this.owner.completionList;
List <Guid> guids2 = guids1;
guids = guids1;
Monitor.Enter(guids2, ref flag);
this.lockTokens.AddRange(this.owner.completionList);
this.owner.completionList.Clear();
}
finally
{
if (flag)
{
Monitor.Exit(guids);
}
}
if (this.lockTokens.Count != 0)
{
MessageReceivePump.BatchCompleteAsyncResult batchCompleteAsyncResult = this;
List <Guid> guids3 = this.lockTokens;
IteratorAsyncResult <MessageReceivePump.BatchCompleteAsyncResult> .BeginCall <Guid> beginCall = (MessageReceivePump.BatchCompleteAsyncResult thisPtr, Guid i, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.receiver.BeginComplete(i, c, s);
yield return(batchCompleteAsyncResult.CallParallelAsync <Guid>(guids3, beginCall, (MessageReceivePump.BatchCompleteAsyncResult thisPtr, Guid i, IAsyncResult r) => thisPtr.owner.receiver.EndComplete(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpFailedToComplete(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, base.LastAsyncStepException.ToString()));
this.owner.RaiseExceptionReceivedEvent(base.LastAsyncStepException, "Complete");
}
}
}
protected override IEnumerator <IteratorAsyncResult <EventHubConsumerGroup.CreateReceiverAsyncResult> .AsyncStep> GetAsyncSteps()
{
if (!this.startingDateTime.HasValue)
{
this.Receiver = new EventHubReceiver(this.owner.MessagingFactory, this.owner.EventHubPath, this.owner.GroupName, this.startingOffset, this.partitionId, this.owner.PrefetchCount, this.epoch, this.offsetInclusive);
}
else
{
this.Receiver = new EventHubReceiver(this.owner.MessagingFactory, this.owner.EventHubPath, this.owner.GroupName, this.startingDateTime, this.partitionId, this.owner.PrefetchCount, this.epoch);
}
if (this.Receiver != null)
{
EventHubConsumerGroup.CreateReceiverAsyncResult createReceiverAsyncResult = this;
IteratorAsyncResult <EventHubConsumerGroup.CreateReceiverAsyncResult> .BeginCall beginCall = (EventHubConsumerGroup.CreateReceiverAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.Receiver.BeginOpen(t, c, s);
yield return(createReceiverAsyncResult.CallAsync(beginCall, (EventHubConsumerGroup.CreateReceiverAsyncResult thisPtr, IAsyncResult r) => thisPtr.Receiver.EndOpen(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
this.owner.RegisterMessageClientEntity(this.Receiver);
}
}
protected override IEnumerator <IteratorAsyncResult <MessageReceivePump.DispatchAsyncResult> .AsyncStep> GetAsyncSteps()
{
TimeSpan timeSpan;
if (this.ShouldRenewLock())
{
this.owner.ScheduleRenewLockLoop(this.trackingContext, this.message, this.renewCancellationTokenSource.Token);
this.processingTimer.Set(this.owner.OnMessageOptions.AutoRenewTimeout);
}
MessageReceivePump.DispatchAsyncResult dispatchAsyncResult = this;
IteratorAsyncResult <MessageReceivePump.DispatchAsyncResult> .BeginCall beginCall = (MessageReceivePump.DispatchAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.beginCallback(thisPtr.message, c, s);
yield return(dispatchAsyncResult.CallAsync(beginCall, (MessageReceivePump.DispatchAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.endCallback(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (this.ShouldRenewLock())
{
this.processingTimer.Cancel();
this.renewCancellationTokenSource.Cancel();
this.renewCancellationTokenSource.Dispose();
}
if (base.LastAsyncStepException != null)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpUserCallbackException(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, base.LastAsyncStepException.ToString()));
this.owner.RaiseExceptionReceivedEvent(base.LastAsyncStepException, "UserCallback");
}
if (this.owner.receiver.Mode == ReceiveMode.PeekLock)
{
if (base.LastAsyncStepException != null)
{
MessageReceivePump.DispatchAsyncResult dispatchAsyncResult1 = this;
IteratorAsyncResult <MessageReceivePump.DispatchAsyncResult> .BeginCall beginCall1 = (MessageReceivePump.DispatchAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.receiver.BeginAbandon(thisPtr.message.LockToken, c, s);
yield return(dispatchAsyncResult1.CallAsync(beginCall1, (MessageReceivePump.DispatchAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.receiver.EndAbandon(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpFailedToAbandon(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, base.LastAsyncStepException.ToString()));
this.owner.RaiseExceptionReceivedEvent(base.LastAsyncStepException, "Abandon");
}
}
else if (this.owner.OnMessageOptions.AutoComplete)
{
this.owner.ScheduleMessageCompletion(this.message, this.trackingContext);
}
bool lastAsyncStepException = base.LastAsyncStepException != null;
if (lastAsyncStepException && MessageReceivePump.ShouldBackoff(base.LastAsyncStepException, out timeSpan))
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpBackoff(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, (int)MessageReceivePump.ServerBusyExceptionBackoffAmount.TotalMilliseconds, base.LastAsyncStepException.ToString()));
yield return(base.CallAsyncSleep(timeSpan));
}
}
}
protected override IEnumerator <IteratorAsyncResult <SendAvailabilityPairedNamespaceMessageSender.CloseAsyncResult> .AsyncStep> GetAsyncSteps()
{
SendAvailabilityPairedNamespaceMessageSender.CloseAsyncResult closeAsyncResult = this;
ICollection <MessageSender> messageSenders = this.senders;
IteratorAsyncResult <SendAvailabilityPairedNamespaceMessageSender.CloseAsyncResult> .BeginCall <MessageSender> beginCall = (SendAvailabilityPairedNamespaceMessageSender.CloseAsyncResult thisPtr, MessageSender i, TimeSpan t, AsyncCallback c, object s) => i.BeginClose(t, c, s);
yield return(closeAsyncResult.CallParallelAsync <MessageSender>(messageSenders, beginCall, (SendAvailabilityPairedNamespaceMessageSender.CloseAsyncResult thisPtr, MessageSender i, IAsyncResult r) => i.EndClose(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
protected override IEnumerator <IteratorAsyncResult <MessageReceivePump.PumpAsyncResult> .AsyncStep> GetAsyncSteps()
{
TimeSpan timeSpan;
while (this.owner.receiver.IsOpened)
{
if (!this.owner.semaphore.TryEnter())
{
MessageReceivePump.PumpAsyncResult pumpAsyncResult = this;
IteratorAsyncResult <MessageReceivePump.PumpAsyncResult> .BeginCall beginCall = (MessageReceivePump.PumpAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.semaphore.BeginEnter(c, s);
yield return(pumpAsyncResult.CallAsync(beginCall, (MessageReceivePump.PumpAsyncResult thisPtr, IAsyncResult r) => thisPtr.owner.semaphore.EndEnter(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer));
}
this.message = null;
if (this.firstMessage != null)
{
this.message = this.firstMessage;
this.firstMessage = null;
}
else
{
MessageReceivePump.PumpAsyncResult pumpAsyncResult1 = this;
IteratorAsyncResult <MessageReceivePump.PumpAsyncResult> .BeginCall beginCall1 = (MessageReceivePump.PumpAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.receiver.BeginReceive(thisPtr.owner.OnMessageOptions.ReceiveTimeOut, c, s);
yield return(pumpAsyncResult1.CallAsync(beginCall1, (MessageReceivePump.PumpAsyncResult thisPtr, IAsyncResult r) => thisPtr.message = thisPtr.owner.receiver.EndReceive(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
}
if (base.LastAsyncStepException != null)
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpReceiveException(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, base.LastAsyncStepException.ToString()));
this.owner.RaiseExceptionReceivedEvent(base.LastAsyncStepException, "Receive");
if (MessageReceivePump.ShouldBackoff(base.LastAsyncStepException, out timeSpan))
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpBackoff(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker, (int)MessageReceivePump.ServerBusyExceptionBackoffAmount.TotalMilliseconds, base.LastAsyncStepException.ToString()));
yield return(base.CallAsyncSleep(timeSpan));
}
}
if (this.message != null)
{
try
{
(new MessageReceivePump.DispatchAsyncResult(this.owner, this.trackingContext, this.message, MessageReceivePump.PumpAsyncResult.onDispatchCompleted, this.owner)).Start();
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.owner.semaphore.Exit();
}
}
else
{
this.owner.semaphore.Exit();
}
}
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpStopped(this.trackingContext.Activity, this.trackingContext.TrackingId, this.trackingContext.SystemTracker));
}
protected override IEnumerator <IteratorAsyncResult <SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult> .AsyncStep> GetAsyncSteps()
{
Exception exception = this.sender.Options.RetrieveNontransientException(this.sender.Primary.Path);
if (exception != null)
{
throw Fx.Exception.AsError(new SendAvailabilityMessagingException(exception), null);
}
if (this.sender.CanUsePrimary())
{
SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult sendAsyncResult = this;
IteratorAsyncResult <SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult> .BeginCall beginCall = (SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.sender.Primary.BeginSend(thisPtr.trackingContext, thisPtr.messages, t, c, s);
yield return(sendAsyncResult.CallAsync(beginCall, (SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult thisPtr, IAsyncResult r) => thisPtr.sender.Primary.EndSend(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException != null)
{
if (!this.sender.Options.ExceptionInspector.CausesFailover(base.LastAsyncStepException))
{
goto Label1;
}
this.sender.Options.NotifyPrimarySendResult(this.sender.Primary.Path, false);
}
else
{
this.sender.Options.MarkPathHealthy(this.sender.Path);
goto Label0;
}
}
if (!this.sender.CanUsePrimary())
{
if (this.messageBuffer.Count > 0)
{
SendAvailabilityPairedNamespaceMessageSender.ConvertMessagesForBacklog(this.messageBuffer, this.sender.Primary.Path);
while (base.RemainingTime() > this.SafeBacklogAttempt || base.RemainingTime() > TimeSpan.FromTicks(base.OriginalTimeout.Ticks / (long)2))
{
List <BrokeredMessage> list = null;
List <BrokeredMessage> brokeredMessages = this.messageBuffer;
list = (
from msg in brokeredMessages
select msg.Clone()).ToList <BrokeredMessage>();
try
{
SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult sendAsyncResult1 = this;
IteratorAsyncResult <SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult> .BeginCall beginCall1 = (SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.sender.Backlog.BeginSend(list, t, c, s);
yield return(sendAsyncResult1.CallAsync(beginCall1, (SendAvailabilityPairedNamespaceMessageSender.SendAsyncResult thisPtr, IAsyncResult r) => thisPtr.sender.Backlog.EndSend(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
}
finally
{
if (list != null)
{
list.ForEach((BrokeredMessage msg) => msg.Dispose());
list.Clear();
}
}
if (base.LastAsyncStepException == null)
{
break;
}
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWritePairedNamespaceSendToBacklogFailed(this.sender.MessagingFactory.Address.ToString(), this.sender.Backlog.Path, base.LastAsyncStepException));
if (!(base.RemainingTime() > TimeSpan.Zero) || this.sender.Options.BacklogQueueCount <= 1)
{
break;
}
this.sender.FindNewMessageSender(this.sender.Backlog.Path);
}
}
List <BrokeredMessage> brokeredMessages1 = this.messageBuffer;
brokeredMessages1.ForEach((BrokeredMessage msg) => msg.Dispose());
this.messageBuffer.Clear();
base.Complete(base.LastAsyncStepException);
}
else
{
base.Complete(base.LastAsyncStepException);
}
Label0:
yield break;
Label1:
base.Complete(base.LastAsyncStepException);
goto Label0;
}
protected override IEnumerator <IteratorAsyncResult <MessageReceivePump.RenewLockLoopAsyncResult> .AsyncStep> GetAsyncSteps()
{
while (!this.pump.receiver.IsClosed && !this.cancellationToken.IsCancellationRequested)
{
yield return(base.CallAsyncSleep(this.CalculateRenewAfterDuration(), this.cancellationToken));
if (this.cancellationToken.IsCancellationRequested)
{
break;
}
MessageReceivePump.RenewLockLoopAsyncResult renewLockLoopAsyncResult = this;
IteratorAsyncResult <MessageReceivePump.RenewLockLoopAsyncResult> .BeginCall beginCall = (MessageReceivePump.RenewLockLoopAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.message.BeginRenewLock(c, s);
yield return(renewLockLoopAsyncResult.CallAsync(beginCall, (MessageReceivePump.RenewLockLoopAsyncResult thisPtr, IAsyncResult r) => thisPtr.message.EndRenewLock(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue));
if (base.LastAsyncStepException == null)
{
continue;
}
Exception lastAsyncStepException = base.LastAsyncStepException;
if (!(lastAsyncStepException is NotSupportedException))
{
if (lastAsyncStepException is MessageLockLostException || lastAsyncStepException is ObjectDisposedException)
{
break;
}
if (!(lastAsyncStepException is InvalidOperationException))
{
if (lastAsyncStepException is OperationCanceledException)
{
break;
}
this.pump.RaiseExceptionReceivedEvent(lastAsyncStepException, "RenewLock");
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpRenewLockFailed(this.trackingContext.Activity, this.trackingContext.SystemTracker, this.trackingContext.TrackingId, this.message.MessageId, lastAsyncStepException.ToStringSlim()));
}
else
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpRenewLockInvalidOperation(this.trackingContext.Activity, this.trackingContext.SystemTracker, this.trackingContext.TrackingId, this.message.MessageId, lastAsyncStepException.ToStringSlim()));
break;
}
}
else
{
MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.MessageReceivePumpRenewLockNotSupported(this.trackingContext.Activity, this.trackingContext.SystemTracker, this.trackingContext.TrackingId, this.message.MessageId, lastAsyncStepException.ToStringSlim()));
this.pump.renewSupported = false;
break;
}
}
}
