public void OnLocalFault(Exception e, Message faultMessage, RequestContext context)
{
if ((this.channel.Aborted || (this.channel.State == CommunicationState.Faulted)) || (this.channel.State == CommunicationState.Closed))
{
if (faultMessage != null)
{
faultMessage.Close();
}
if (context != null)
{
context.Abort();
}
}
else
{
lock (this.ThisLock)
{
if (this.faulted != SessionFaultState.NotFaulted)
{
return;
}
this.faulted = SessionFaultState.LocallyFaulted;
this.terminatingFault = faultMessage;
this.replyFaultContext = context;
}
this.FaultCore();
this.channel.Fault(e);
this.UnblockChannelIfNecessary();
}
}
public virtual void OnFaulted()
{
bool flag;
this.FaultCore();
lock (this.ThisLock)
{
if ((this.faulted == SessionFaultState.NotFaulted) || (this.faulted == SessionFaultState.CleanedUp))
{
return;
}
flag = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted);
this.faulted = SessionFaultState.CleanedUp;
}
if ((((!flag || (this.binder.State != CommunicationState.Opened)) || !this.binder.Connected) || (!this.binder.CanSendAsynchronously && (this.replyFaultContext == null))) || (this.terminatingFault == null))
{
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
else
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
}
}
public virtual void Abort()
{
this.guard.Abort();
this.inactivityTimer.Abort();
// Try to send a fault.
bool sendFault;
lock (this.ThisLock)
{
// Faulted thread already cleaned up. No need to to anything more.
if (this.faulted == SessionFaultState.CleanedUp)
{
return;
}
// Can only send a fault if the other side did not send one already.
sendFault = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted); // NotFaulted || LocallyFaulted
this.faulted = SessionFaultState.CleanedUp;
}
if (sendFault)
{
if ((this.binder.State == CommunicationState.Opened) &&
this.binder.Connected &&
(this.binder.CanSendAsynchronously || (this.replyFaultContext != null)))
{
if (this.terminatingFault == null)
{
UniqueId sequenceId = this.InputID ?? this.OutputID;
if (sequenceId != null)
{
WsrmFault fault = SequenceTerminatedFault.CreateCommunicationFault(sequenceId, SR.GetString(SR.SequenceTerminatedOnAbort), null);
this.terminatingFault = fault.CreateMessage(this.settings.MessageVersion,
this.settings.ReliableMessagingVersion);
}
}
if (this.terminatingFault != null)
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
}
// Got here so the session did not actually send a fault, must clean up resources.
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
public virtual void OnFaulted()
{
this.FaultCore();
// Try to send a fault.
bool sendFault;
lock (this.ThisLock)
{
// Channel was faulted without the session being told first (e.g. open throws).
// The session does not know what fault to send so let abort send it if it can.
if (this.faulted == SessionFaultState.NotFaulted)
{
return;
}
// Abort thread decided to clean up.
if (this.faulted == SessionFaultState.CleanedUp)
{
return;
}
// Can only send a fault if the other side did not send one already.
sendFault = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted); // LocallyFaulted
this.faulted = SessionFaultState.CleanedUp;
}
if (sendFault)
{
if ((this.binder.State == CommunicationState.Opened) &&
this.binder.Connected &&
(this.binder.CanSendAsynchronously || (this.replyFaultContext != null)) &&
(this.terminatingFault != null))
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
// Got here so the session did not actually send a fault, must clean up resources.
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
public void OnRemoteFault(Exception e)
{
if ((!this.channel.Aborted && (this.channel.State != CommunicationState.Faulted)) && (this.channel.State != CommunicationState.Closed))
{
lock (this.ThisLock)
{
if (this.faulted != SessionFaultState.NotFaulted)
{
return;
}
this.faulted = SessionFaultState.RemotelyFaulted;
}
this.FaultCore();
this.channel.Fault(e);
this.UnblockChannelIfNecessary();
}
}
public virtual void Abort()
{
bool flag;
this.guard.Abort();
this.inactivityTimer.Abort();
lock (this.ThisLock)
{
if (this.faulted == SessionFaultState.CleanedUp)
{
return;
}
flag = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted);
this.faulted = SessionFaultState.CleanedUp;
}
if (((flag && (this.binder.State == CommunicationState.Opened)) && this.binder.Connected) && (this.binder.CanSendAsynchronously || (this.replyFaultContext != null)))
{
if (this.terminatingFault == null)
{
UniqueId sequenceID = this.InputID ?? this.OutputID;
if (sequenceID != null)
{
this.terminatingFault = SequenceTerminatedFault.CreateCommunicationFault(sequenceID, System.ServiceModel.SR.GetString("SequenceTerminatedOnAbort"), null).CreateMessage(this.settings.MessageVersion, this.settings.ReliableMessagingVersion);
}
}
if (this.terminatingFault != null)
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
public virtual void Abort()
{
bool flag;
this.guard.Abort();
this.inactivityTimer.Abort();
lock (this.ThisLock)
{
if (this.faulted == SessionFaultState.CleanedUp)
{
return;
}
flag = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted);
this.faulted = SessionFaultState.CleanedUp;
}
if (((flag && (this.binder.State == CommunicationState.Opened)) && this.binder.Connected) && (this.binder.CanSendAsynchronously || (this.replyFaultContext != null)))
{
if (this.terminatingFault == null)
{
UniqueId sequenceID = this.InputID ?? this.OutputID;
if (sequenceID != null)
{
this.terminatingFault = SequenceTerminatedFault.CreateCommunicationFault(sequenceID, System.ServiceModel.SR.GetString("SequenceTerminatedOnAbort"), null).CreateMessage(this.settings.MessageVersion, this.settings.ReliableMessagingVersion);
}
}
if (this.terminatingFault != null)
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
public virtual void OnFaulted()
{
this.FaultCore();
// Try to send a fault.
bool sendFault;
lock (this.ThisLock)
{
// Channel was faulted without the session being told first (e.g. open throws).
// The session does not know what fault to send so let abort send it if it can.
if (this.faulted == SessionFaultState.NotFaulted)
return;
// Abort thread decided to clean up.
if (this.faulted == SessionFaultState.CleanedUp)
return;
// Can only send a fault if the other side did not send one already.
sendFault = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted); // LocallyFaulted
this.faulted = SessionFaultState.CleanedUp;
}
if (sendFault)
{
if ((this.binder.State == CommunicationState.Opened)
&& this.binder.Connected
&& (this.binder.CanSendAsynchronously || (this.replyFaultContext != null))
&& (this.terminatingFault != null))
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
// Got here so the session did not actually send a fault, must clean up resources.
if (this.terminatingFault != null)
this.terminatingFault.Close();
if (this.replyFaultContext != null)
this.replyFaultContext.Abort();
this.binder.Abort();
}
public void OnRemoteFault(Exception e)
{
if (this.channel.Aborted ||
this.channel.State == CommunicationState.Faulted ||
this.channel.State == CommunicationState.Closed)
{
return;
}
lock (this.ThisLock)
{
if (this.faulted != SessionFaultState.NotFaulted)
return;
this.faulted = SessionFaultState.RemotelyFaulted;
}
this.FaultCore();
this.channel.Fault(e);
this.UnblockChannelIfNecessary();
}
public void OnLocalFault(Exception e, Message faultMessage, RequestContext context)
{
if (this.channel.Aborted ||
this.channel.State == CommunicationState.Faulted ||
this.channel.State == CommunicationState.Closed)
{
if (faultMessage != null)
faultMessage.Close();
if (context != null)
context.Abort();
return;
}
lock (this.ThisLock)
{
if (this.faulted != SessionFaultState.NotFaulted)
return;
this.faulted = SessionFaultState.LocallyFaulted;
this.terminatingFault = faultMessage;
this.replyFaultContext = context;
}
this.FaultCore();
this.channel.Fault(e);
this.UnblockChannelIfNecessary();
}
public virtual void Abort()
{
this.guard.Abort();
this.inactivityTimer.Abort();
// Try to send a fault.
bool sendFault;
lock (this.ThisLock)
{
// Faulted thread already cleaned up. No need to to anything more.
if (this.faulted == SessionFaultState.CleanedUp)
return;
// Can only send a fault if the other side did not send one already.
sendFault = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted); // NotFaulted || LocallyFaulted
this.faulted = SessionFaultState.CleanedUp;
}
if (sendFault)
{
if ((this.binder.State == CommunicationState.Opened)
&& this.binder.Connected
&& (this.binder.CanSendAsynchronously || (this.replyFaultContext != null)))
{
if (this.terminatingFault == null)
{
UniqueId sequenceId = this.InputID ?? this.OutputID;
if (sequenceId != null)
{
WsrmFault fault = SequenceTerminatedFault.CreateCommunicationFault(sequenceId, SR.GetString(SR.SequenceTerminatedOnAbort), null);
this.terminatingFault = fault.CreateMessage(this.settings.MessageVersion,
this.settings.ReliableMessagingVersion);
}
}
if (this.terminatingFault != null)
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
return;
}
}
}
// Got here so the session did not actually send a fault, must clean up resources.
if (this.terminatingFault != null)
this.terminatingFault.Close();
if (this.replyFaultContext != null)
this.replyFaultContext.Abort();
this.binder.Abort();
}
public virtual void OnFaulted()
{
bool flag;
this.FaultCore();
lock (this.ThisLock)
{
if ((this.faulted == SessionFaultState.NotFaulted) || (this.faulted == SessionFaultState.CleanedUp))
{
return;
}
flag = this.canSendFault && (this.faulted != SessionFaultState.RemotelyFaulted);
this.faulted = SessionFaultState.CleanedUp;
}
if ((((!flag || (this.binder.State != CommunicationState.Opened)) || !this.binder.Connected) || (!this.binder.CanSendAsynchronously && (this.replyFaultContext == null))) || (this.terminatingFault == null))
{
if (this.terminatingFault != null)
{
this.terminatingFault.Close();
}
if (this.replyFaultContext != null)
{
this.replyFaultContext.Abort();
}
this.binder.Abort();
}
else
{
this.AddFinalRanges();
this.faultHelper.SendFaultAsync(this.binder, this.replyFaultContext, this.terminatingFault);
}
}
