mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
835 lines
27 KiB
C#
835 lines
27 KiB
C#
//----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Runtime;
|
|
using System.Threading;
|
|
using System.Xml;
|
|
|
|
delegate IAsyncResult BeginSendHandler(MessageAttemptInfo attemptInfo, TimeSpan timeout, bool maskUnhandledException, AsyncCallback asyncCallback, object state);
|
|
delegate void EndSendHandler(IAsyncResult result);
|
|
delegate void SendHandler(MessageAttemptInfo attemptInfo, TimeSpan timeout, bool maskUnhandledException);
|
|
delegate void ComponentFaultedHandler(Exception faultException, WsrmFault fault);
|
|
delegate void ComponentExceptionHandler(Exception exception);
|
|
delegate void RetryHandler(MessageAttemptInfo attemptInfo);
|
|
|
|
sealed class ReliableOutputConnection
|
|
{
|
|
BeginSendHandler beginSendHandler;
|
|
OperationWithTimeoutBeginCallback beginSendAckRequestedHandler;
|
|
bool closed = false;
|
|
EndSendHandler endSendHandler;
|
|
OperationEndCallback endSendAckRequestedHandler;
|
|
UniqueId id;
|
|
MessageVersion messageVersion;
|
|
object mutex = new Object();
|
|
static AsyncCallback onSendRetriesComplete = Fx.ThunkCallback(new AsyncCallback(OnSendRetriesComplete));
|
|
static AsyncCallback onSendRetryComplete = Fx.ThunkCallback(new AsyncCallback(OnSendRetryComplete));
|
|
ReliableMessagingVersion reliableMessagingVersion;
|
|
Guard sendGuard = new Guard(Int32.MaxValue);
|
|
SendHandler sendHandler;
|
|
OperationWithTimeoutCallback sendAckRequestedHandler;
|
|
static Action<object> sendRetries = new Action<object>(SendRetries);
|
|
TimeSpan sendTimeout;
|
|
InterruptibleWaitObject shutdownHandle = new InterruptibleWaitObject(false);
|
|
TransmissionStrategy strategy;
|
|
bool terminated = false;
|
|
|
|
public ReliableOutputConnection(UniqueId id,
|
|
int maxTransferWindowSize,
|
|
MessageVersion messageVersion,
|
|
ReliableMessagingVersion reliableMessagingVersion,
|
|
TimeSpan initialRtt,
|
|
bool requestAcks,
|
|
TimeSpan sendTimeout)
|
|
{
|
|
this.id = id;
|
|
this.messageVersion = messageVersion;
|
|
this.reliableMessagingVersion = reliableMessagingVersion;
|
|
this.sendTimeout = sendTimeout;
|
|
this.strategy = new TransmissionStrategy(reliableMessagingVersion, initialRtt, maxTransferWindowSize,
|
|
requestAcks, id);
|
|
this.strategy.RetryTimeoutElapsed = OnRetryTimeoutElapsed;
|
|
this.strategy.OnException = RaiseOnException;
|
|
}
|
|
|
|
public ComponentFaultedHandler Faulted;
|
|
public ComponentExceptionHandler OnException;
|
|
|
|
MessageVersion MessageVersion
|
|
{
|
|
get
|
|
{
|
|
return this.messageVersion;
|
|
}
|
|
}
|
|
|
|
public BeginSendHandler BeginSendHandler
|
|
{
|
|
set
|
|
{
|
|
this.beginSendHandler = value;
|
|
}
|
|
}
|
|
|
|
public OperationWithTimeoutBeginCallback BeginSendAckRequestedHandler
|
|
{
|
|
set
|
|
{
|
|
this.beginSendAckRequestedHandler = value;
|
|
}
|
|
}
|
|
|
|
public bool Closed
|
|
{
|
|
get
|
|
{
|
|
return this.closed;
|
|
}
|
|
}
|
|
|
|
public EndSendHandler EndSendHandler
|
|
{
|
|
set
|
|
{
|
|
this.endSendHandler = value;
|
|
}
|
|
}
|
|
|
|
public OperationEndCallback EndSendAckRequestedHandler
|
|
{
|
|
set
|
|
{
|
|
this.endSendAckRequestedHandler = value;
|
|
}
|
|
}
|
|
|
|
public Int64 Last
|
|
{
|
|
get
|
|
{
|
|
return this.strategy.Last;
|
|
}
|
|
}
|
|
|
|
public SendHandler SendHandler
|
|
{
|
|
set
|
|
{
|
|
this.sendHandler = value;
|
|
}
|
|
}
|
|
|
|
public OperationWithTimeoutCallback SendAckRequestedHandler
|
|
{
|
|
set
|
|
{
|
|
this.sendAckRequestedHandler = value;
|
|
}
|
|
}
|
|
|
|
public TransmissionStrategy Strategy
|
|
{
|
|
get
|
|
{
|
|
return this.strategy;
|
|
}
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get { return this.mutex; }
|
|
}
|
|
|
|
public void Abort(ChannelBase channel)
|
|
{
|
|
this.sendGuard.Abort();
|
|
this.shutdownHandle.Abort(channel);
|
|
this.strategy.Abort(channel);
|
|
}
|
|
|
|
void CompleteTransfer(TimeSpan timeout)
|
|
{
|
|
if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
Message message = Message.CreateMessage(this.MessageVersion, WsrmFeb2005Strings.LastMessageAction);
|
|
message.Properties.AllowOutputBatching = false;
|
|
|
|
// Return value ignored.
|
|
this.InternalAddMessage(message, timeout, null, true);
|
|
}
|
|
else if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
if (this.strategy.SetLast())
|
|
{
|
|
this.shutdownHandle.Set();
|
|
}
|
|
else
|
|
{
|
|
this.sendAckRequestedHandler(timeout);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw Fx.AssertAndThrow("Unsupported version.");
|
|
}
|
|
}
|
|
|
|
public bool AddMessage(Message message, TimeSpan timeout, object state)
|
|
{
|
|
return this.InternalAddMessage(message, timeout, state, false);
|
|
}
|
|
|
|
public IAsyncResult BeginAddMessage(Message message, TimeSpan timeout, object state, AsyncCallback callback, object asyncState)
|
|
{
|
|
return new AddAsyncResult(message, false, timeout, state, this, callback, asyncState);
|
|
}
|
|
|
|
public bool EndAddMessage(IAsyncResult result)
|
|
{
|
|
return AddAsyncResult.End(result);
|
|
}
|
|
|
|
IAsyncResult BeginCompleteTransfer(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
Message message = Message.CreateMessage(this.MessageVersion, WsrmFeb2005Strings.LastMessageAction);
|
|
message.Properties.AllowOutputBatching = false;
|
|
return new AddAsyncResult(message, true, timeout, null, this, callback, state);
|
|
}
|
|
else if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
if (this.strategy.SetLast())
|
|
{
|
|
this.shutdownHandle.Set();
|
|
return new AlreadyCompletedTransferAsyncResult(callback, state);
|
|
}
|
|
else
|
|
{
|
|
return this.beginSendAckRequestedHandler(timeout, callback, state);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw Fx.AssertAndThrow("Unsupported version.");
|
|
}
|
|
}
|
|
|
|
void EndCompleteTransfer(IAsyncResult result)
|
|
{
|
|
if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
AddAsyncResult.End(result);
|
|
}
|
|
else if (this.reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
AlreadyCompletedTransferAsyncResult completedResult = result as AlreadyCompletedTransferAsyncResult;
|
|
if (completedResult != null)
|
|
{
|
|
completedResult.End();
|
|
}
|
|
else
|
|
{
|
|
this.endSendAckRequestedHandler(result);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw Fx.AssertAndThrow("Unsupported version.");
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
bool completeTransfer = false;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
completeTransfer = !this.closed;
|
|
this.closed = true;
|
|
}
|
|
|
|
OperationWithTimeoutBeginCallback[] beginCallbacks;
|
|
OperationEndCallback[] endCallbacks;
|
|
|
|
beginCallbacks = new OperationWithTimeoutBeginCallback[] {
|
|
completeTransfer ? this.BeginCompleteTransfer : default(OperationWithTimeoutBeginCallback),
|
|
this.shutdownHandle.BeginWait,
|
|
this.sendGuard.BeginClose,
|
|
this.beginSendAckRequestedHandler };
|
|
|
|
endCallbacks = new OperationEndCallback[] {
|
|
completeTransfer ? this.EndCompleteTransfer : default(OperationEndCallback),
|
|
this.shutdownHandle.EndWait,
|
|
this.sendGuard.EndClose,
|
|
this.endSendAckRequestedHandler };
|
|
|
|
return OperationWithTimeoutComposer.BeginComposeAsyncOperations(timeout, beginCallbacks, endCallbacks, callback, state);
|
|
}
|
|
|
|
public bool CheckForTermination()
|
|
{
|
|
return this.strategy.DoneTransmitting;
|
|
}
|
|
|
|
public void Close(TimeSpan timeout)
|
|
{
|
|
bool completeTransfer = false;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
completeTransfer = !this.closed;
|
|
this.closed = true;
|
|
}
|
|
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
|
|
if (completeTransfer)
|
|
{
|
|
this.CompleteTransfer(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
this.shutdownHandle.Wait(timeoutHelper.RemainingTime());
|
|
this.sendGuard.Close(timeoutHelper.RemainingTime());
|
|
this.strategy.Close();
|
|
}
|
|
|
|
void CompleteSendRetries(IAsyncResult result)
|
|
{
|
|
while (true)
|
|
{
|
|
this.endSendHandler(result);
|
|
this.sendGuard.Exit();
|
|
this.strategy.DequeuePending();
|
|
|
|
if (this.sendGuard.Enter())
|
|
{
|
|
MessageAttemptInfo attemptInfo = this.strategy.GetMessageInfoForRetry(true);
|
|
|
|
if (attemptInfo.Message == null)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
result = this.beginSendHandler(attemptInfo, this.sendTimeout, true, onSendRetriesComplete, this);
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// We are here if there are no more messages to retry.
|
|
this.sendGuard.Exit();
|
|
this.OnTransferComplete();
|
|
}
|
|
|
|
void CompleteSendRetry(IAsyncResult result)
|
|
{
|
|
try
|
|
{
|
|
this.endSendHandler(result);
|
|
}
|
|
finally
|
|
{
|
|
this.sendGuard.Exit();
|
|
}
|
|
}
|
|
|
|
public void EndClose(IAsyncResult result)
|
|
{
|
|
OperationWithTimeoutComposer.EndComposeAsyncOperations(result);
|
|
this.strategy.Close();
|
|
}
|
|
|
|
public void Fault(ChannelBase channel)
|
|
{
|
|
this.sendGuard.Abort();
|
|
this.shutdownHandle.Fault(channel);
|
|
this.strategy.Fault(channel);
|
|
}
|
|
|
|
bool InternalAddMessage(Message message, TimeSpan timeout, object state, bool isLast)
|
|
{
|
|
MessageAttemptInfo attemptInfo;
|
|
TimeoutHelper helper = new TimeoutHelper(timeout);
|
|
|
|
try
|
|
{
|
|
if (isLast)
|
|
{
|
|
if (state != null)
|
|
{
|
|
throw Fx.AssertAndThrow("The isLast overload does not take a state.");
|
|
}
|
|
|
|
attemptInfo = this.strategy.AddLast(message, helper.RemainingTime(), null);
|
|
}
|
|
else if (!this.strategy.Add(message, helper.RemainingTime(), state, out attemptInfo))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
if (isLast)
|
|
this.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.id, SR.GetString(SR.SequenceTerminatedAddLastToWindowTimedOut), null));
|
|
// else - RM does not fault the channel based on a timeout exception trying to add a sequenced message to the window.
|
|
|
|
throw;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (!Fx.IsFatal(e))
|
|
this.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.id, SR.GetString(SR.SequenceTerminatedUnknownAddToWindowError), null));
|
|
|
|
throw;
|
|
}
|
|
|
|
if (sendGuard.Enter())
|
|
{
|
|
try
|
|
{
|
|
this.sendHandler(attemptInfo, helper.RemainingTime(), false);
|
|
}
|
|
catch (QuotaExceededException)
|
|
{
|
|
this.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.id));
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
this.sendGuard.Exit();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool IsFinalAckConsistent(SequenceRangeCollection ranges)
|
|
{
|
|
return this.strategy.IsFinalAckConsistent(ranges);
|
|
}
|
|
|
|
void OnRetryTimeoutElapsed(MessageAttemptInfo attemptInfo)
|
|
{
|
|
if (this.sendGuard.Enter())
|
|
{
|
|
IAsyncResult result = this.beginSendHandler(attemptInfo, this.sendTimeout, true, onSendRetryComplete, this);
|
|
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
this.CompleteSendRetry(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void OnSendRetryComplete(IAsyncResult result)
|
|
{
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
ReliableOutputConnection outputConnection = (ReliableOutputConnection)result.AsyncState;
|
|
|
|
try
|
|
{
|
|
outputConnection.CompleteSendRetry(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
outputConnection.RaiseOnException(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void OnSendRetriesComplete(IAsyncResult result)
|
|
{
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
ReliableOutputConnection outputConnection = (ReliableOutputConnection)result.AsyncState;
|
|
|
|
try
|
|
{
|
|
outputConnection.CompleteSendRetries(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
outputConnection.RaiseOnException(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnTransferComplete()
|
|
{
|
|
this.strategy.DequeuePending();
|
|
|
|
if (this.strategy.DoneTransmitting)
|
|
Terminate();
|
|
}
|
|
|
|
public void ProcessTransferred(Int64 transferred, SequenceRangeCollection ranges, int quotaRemaining)
|
|
{
|
|
if (transferred < 0)
|
|
{
|
|
throw Fx.AssertAndThrow("Argument transferred must be a valid sequence number or 0 for protocol messages.");
|
|
}
|
|
|
|
bool invalidAck;
|
|
|
|
// ignored, TransmissionStrategy is being used to keep track of what must be re-sent.
|
|
// In the Request-Reply case this state may not align with acks.
|
|
bool inconsistentAck;
|
|
|
|
this.strategy.ProcessAcknowledgement(ranges, out invalidAck, out inconsistentAck);
|
|
invalidAck = (invalidAck || ((transferred != 0) && !ranges.Contains(transferred)));
|
|
|
|
if (!invalidAck)
|
|
{
|
|
if ((transferred > 0) && this.strategy.ProcessTransferred(transferred, quotaRemaining))
|
|
{
|
|
ActionItem.Schedule(sendRetries, this);
|
|
}
|
|
else
|
|
{
|
|
this.OnTransferComplete();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WsrmFault fault = new InvalidAcknowledgementFault(this.id, ranges);
|
|
RaiseFault(fault.CreateException(), fault);
|
|
}
|
|
}
|
|
|
|
public void ProcessTransferred(SequenceRangeCollection ranges, int quotaRemaining)
|
|
{
|
|
bool invalidAck;
|
|
bool inconsistentAck;
|
|
|
|
this.strategy.ProcessAcknowledgement(ranges, out invalidAck, out inconsistentAck);
|
|
|
|
if (!invalidAck && !inconsistentAck)
|
|
{
|
|
if (this.strategy.ProcessTransferred(ranges, quotaRemaining))
|
|
{
|
|
ActionItem.Schedule(sendRetries, this);
|
|
}
|
|
else
|
|
{
|
|
this.OnTransferComplete();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WsrmFault fault = new InvalidAcknowledgementFault(this.id, ranges);
|
|
RaiseFault(fault.CreateException(), fault);
|
|
}
|
|
}
|
|
|
|
void RaiseFault(Exception faultException, WsrmFault fault)
|
|
{
|
|
ComponentFaultedHandler handler = this.Faulted;
|
|
|
|
if (handler != null)
|
|
handler(faultException, fault);
|
|
}
|
|
|
|
void RaiseOnException(Exception exception)
|
|
{
|
|
ComponentExceptionHandler handler = this.OnException;
|
|
|
|
if (handler != null)
|
|
handler(exception);
|
|
}
|
|
|
|
void SendRetries()
|
|
{
|
|
IAsyncResult result = null;
|
|
|
|
if (this.sendGuard.Enter())
|
|
{
|
|
MessageAttemptInfo attemptInfo = this.strategy.GetMessageInfoForRetry(false);
|
|
|
|
if (attemptInfo.Message != null)
|
|
{
|
|
result = this.beginSendHandler(attemptInfo, this.sendTimeout, true, onSendRetriesComplete, this);
|
|
}
|
|
|
|
if (result != null)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
this.CompleteSendRetries(result);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.sendGuard.Exit();
|
|
this.OnTransferComplete();
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SendRetries(object state)
|
|
{
|
|
ReliableOutputConnection outputConnection = (ReliableOutputConnection)state;
|
|
|
|
try
|
|
{
|
|
outputConnection.SendRetries();
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
outputConnection.RaiseOnException(e);
|
|
}
|
|
}
|
|
|
|
public void Terminate()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.terminated)
|
|
return;
|
|
|
|
this.terminated = true;
|
|
}
|
|
|
|
this.shutdownHandle.Set();
|
|
}
|
|
|
|
sealed class AddAsyncResult : AsyncResult
|
|
{
|
|
static AsyncCallback addCompleteStatic = Fx.ThunkCallback(new AsyncCallback(AddComplete));
|
|
ReliableOutputConnection connection;
|
|
bool isLast;
|
|
static AsyncCallback sendCompleteStatic = Fx.ThunkCallback(new AsyncCallback(SendComplete));
|
|
TimeoutHelper timeoutHelper;
|
|
bool validAdd;
|
|
|
|
public AddAsyncResult(Message message, bool isLast, TimeSpan timeout, object state,
|
|
ReliableOutputConnection connection, AsyncCallback callback, object asyncState)
|
|
: base(callback, asyncState)
|
|
{
|
|
this.connection = connection;
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.isLast = isLast;
|
|
|
|
bool complete = false;
|
|
IAsyncResult result;
|
|
|
|
try
|
|
{
|
|
if (isLast)
|
|
{
|
|
if (state != null)
|
|
{
|
|
throw Fx.AssertAndThrow("The isLast overload does not take a state.");
|
|
}
|
|
|
|
result = this.connection.strategy.BeginAddLast(message, this.timeoutHelper.RemainingTime(), state, addCompleteStatic, this);
|
|
}
|
|
else
|
|
{
|
|
result = this.connection.strategy.BeginAdd(message, this.timeoutHelper.RemainingTime(), state, addCompleteStatic, this);
|
|
}
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
if (isLast)
|
|
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedAddLastToWindowTimedOut), null));
|
|
// else - RM does not fault the channel based on a timeout exception trying to add a sequenced message to the window.
|
|
|
|
throw;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (!Fx.IsFatal(e))
|
|
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedUnknownAddToWindowError), null));
|
|
|
|
throw;
|
|
}
|
|
|
|
if (result.CompletedSynchronously)
|
|
complete = this.CompleteAdd(result);
|
|
|
|
if (complete)
|
|
this.Complete(true);
|
|
}
|
|
|
|
static void AddComplete(IAsyncResult result)
|
|
{
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
AddAsyncResult addResult = (AddAsyncResult)result.AsyncState;
|
|
bool complete = false;
|
|
Exception completeException = null;
|
|
|
|
try
|
|
{
|
|
complete = addResult.CompleteAdd(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
completeException = e;
|
|
}
|
|
|
|
if (complete || completeException != null)
|
|
addResult.Complete(false, completeException);
|
|
}
|
|
}
|
|
|
|
bool CompleteAdd(IAsyncResult result)
|
|
{
|
|
MessageAttemptInfo attemptInfo = default(MessageAttemptInfo);
|
|
this.validAdd = true;
|
|
|
|
try
|
|
{
|
|
if (this.isLast)
|
|
{
|
|
attemptInfo = this.connection.strategy.EndAddLast(result);
|
|
}
|
|
else if (!this.connection.strategy.EndAdd(result, out attemptInfo))
|
|
{
|
|
this.validAdd = false;
|
|
return true;
|
|
}
|
|
}
|
|
catch (TimeoutException)
|
|
{
|
|
if (this.isLast)
|
|
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedAddLastToWindowTimedOut), null));
|
|
// else - RM does not fault the channel based on a timeout exception trying to add a sequenced message to the window.
|
|
|
|
throw;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (!Fx.IsFatal(e))
|
|
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateCommunicationFault(this.connection.id, SR.GetString(SR.SequenceTerminatedUnknownAddToWindowError), null));
|
|
|
|
throw;
|
|
}
|
|
|
|
if (this.connection.sendGuard.Enter())
|
|
{
|
|
bool throwing = true;
|
|
|
|
try
|
|
{
|
|
result = this.connection.beginSendHandler(attemptInfo, this.timeoutHelper.RemainingTime(), false, sendCompleteStatic, this);
|
|
throwing = false;
|
|
}
|
|
catch (QuotaExceededException)
|
|
{
|
|
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.connection.id));
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
if (throwing)
|
|
this.connection.sendGuard.Exit();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
this.CompleteSend(result);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void CompleteSend(IAsyncResult result)
|
|
{
|
|
try
|
|
{
|
|
this.connection.endSendHandler(result);
|
|
}
|
|
catch (QuotaExceededException)
|
|
{
|
|
this.connection.RaiseFault(null, SequenceTerminatedFault.CreateQuotaExceededFault(this.connection.id));
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
this.connection.sendGuard.Exit();
|
|
}
|
|
}
|
|
|
|
static void SendComplete(IAsyncResult result)
|
|
{
|
|
if (!result.CompletedSynchronously)
|
|
{
|
|
AddAsyncResult addResult = (AddAsyncResult)result.AsyncState;
|
|
Exception completeException = null;
|
|
|
|
try
|
|
{
|
|
addResult.CompleteSend(result);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
completeException = e;
|
|
}
|
|
|
|
addResult.Complete(false, completeException);
|
|
}
|
|
}
|
|
|
|
public static bool End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<AddAsyncResult>(result);
|
|
return ((AddAsyncResult)result).validAdd;
|
|
}
|
|
}
|
|
|
|
class AlreadyCompletedTransferAsyncResult : CompletedAsyncResult
|
|
{
|
|
public AlreadyCompletedTransferAsyncResult(AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
}
|
|
|
|
public void End()
|
|
{
|
|
AsyncResult.End<AlreadyCompletedTransferAsyncResult>(this);
|
|
}
|
|
}
|
|
}
|
|
}
|