Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

730 lines
26 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Security;
using System.ServiceModel.Diagnostics;
abstract class ClientReliableChannelBinder<TChannel> : ReliableChannelBinder<TChannel>,
IClientReliableChannelBinder
where TChannel : class, IChannel
{
ChannelParameterCollection channelParameters;
IChannelFactory<TChannel> factory;
EndpointAddress to;
Uri via;
protected ClientReliableChannelBinder(EndpointAddress to, Uri via, IChannelFactory<TChannel> factory,
MaskingMode maskingMode, TolerateFaultsMode faultMode, ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
: base(factory.CreateChannel(to, via), maskingMode, faultMode,
defaultCloseTimeout, defaultSendTimeout)
{
if (channelParameters == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channelParameters");
}
this.to = to;
this.via = via;
this.factory = factory;
this.channelParameters = channelParameters;
}
// The server side must get a message to determine where the channel should go, thus it is
// pointless to create a channel for the sake of receiving on the client side. Also, since
// the client side can create channels there receive may enter an infinite loop if open
// persistently throws.
protected override bool CanGetChannelForReceive
{
get
{
return false;
}
}
public override bool CanSendAsynchronously
{
get
{
return true;
}
}
public override ChannelParameterCollection ChannelParameters
{
get
{
return this.channelParameters;
}
}
protected override bool MustCloseChannel
{
get
{
return true;
}
}
protected override bool MustOpenChannel
{
get
{
return true;
}
}
public Uri Via
{
get
{
return this.via;
}
}
public IAsyncResult BeginRequest(Message message, TimeSpan timeout, AsyncCallback callback,
object state)
{
return this.BeginRequest(message, timeout, this.DefaultMaskingMode, callback, state);
}
public IAsyncResult BeginRequest(Message message, TimeSpan timeout, MaskingMode maskingMode,
AsyncCallback callback, object state)
{
RequestAsyncResult result = new RequestAsyncResult(this, callback, state);
result.Start(message, timeout, maskingMode);
return result;
}
protected override IAsyncResult BeginTryGetChannel(TimeSpan timeout,
AsyncCallback callback, object state)
{
CommunicationState currentState = this.State;
TChannel channel;
if ((currentState == CommunicationState.Created)
|| (currentState == CommunicationState.Opening)
|| (currentState == CommunicationState.Opened))
{
channel = this.factory.CreateChannel(this.to, this.via);
}
else
{
channel = null;
}
return new CompletedAsyncResult<TChannel>(channel, callback, state);
}
public static IClientReliableChannelBinder CreateBinder(EndpointAddress to, Uri via,
IChannelFactory<TChannel> factory, MaskingMode maskingMode, TolerateFaultsMode faultMode,
ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
{
Type type = typeof(TChannel);
if (type == typeof(IDuplexChannel))
{
return new DuplexClientReliableChannelBinder(to, via, (IChannelFactory<IDuplexChannel>)(object)factory, maskingMode,
channelParameters, defaultCloseTimeout, defaultSendTimeout);
}
else if (type == typeof(IDuplexSessionChannel))
{
return new DuplexSessionClientReliableChannelBinder(to, via, (IChannelFactory<IDuplexSessionChannel>)(object)factory, maskingMode,
faultMode, channelParameters, defaultCloseTimeout, defaultSendTimeout);
}
else if (type == typeof(IRequestChannel))
{
return new RequestClientReliableChannelBinder(to, via, (IChannelFactory<IRequestChannel>)(object)factory, maskingMode,
channelParameters, defaultCloseTimeout, defaultSendTimeout);
}
else if (type == typeof(IRequestSessionChannel))
{
return new RequestSessionClientReliableChannelBinder(to, via, (IChannelFactory<IRequestSessionChannel>)(object)factory, maskingMode,
faultMode, channelParameters, defaultCloseTimeout, defaultSendTimeout);
}
else
{
throw Fx.AssertAndThrow("ClientReliableChannelBinder supports creation of IDuplexChannel, IDuplexSessionChannel, IRequestChannel, and IRequestSessionChannel only.");
}
}
public Message EndRequest(IAsyncResult result)
{
return RequestAsyncResult.End(result);
}
protected override bool EndTryGetChannel(IAsyncResult result)
{
TChannel channel = CompletedAsyncResult<TChannel>.End(result);
if (channel != null && !this.Synchronizer.SetChannel(channel))
{
channel.Abort();
}
return true;
}
public bool EnsureChannelForRequest()
{
return this.Synchronizer.EnsureChannel();
}
protected override void OnAbort()
{
}
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback,
object state)
{
return new CompletedAsyncResult(callback, state);
}
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback,
object state)
{
return new CompletedAsyncResult(callback, state);
}
protected virtual IAsyncResult OnBeginRequest(TChannel channel, Message message,
TimeSpan timeout, MaskingMode maskingMode, AsyncCallback callback, object state)
{
throw Fx.AssertAndThrow("The derived class does not support the OnBeginRequest operation.");
}
protected override void OnClose(TimeSpan timeout)
{
}
protected override void OnEndClose(IAsyncResult result)
{
CompletedAsyncResult.End(result);
}
protected override void OnEndOpen(IAsyncResult result)
{
CompletedAsyncResult.End(result);
}
protected virtual Message OnEndRequest(TChannel channel, MaskingMode maskingMode,
IAsyncResult result)
{
throw Fx.AssertAndThrow("The derived class does not support the OnEndRequest operation.");
}
protected override void OnOpen(TimeSpan timeout)
{
}
protected virtual Message OnRequest(TChannel channel, Message message, TimeSpan timeout,
MaskingMode maskingMode)
{
throw Fx.AssertAndThrow("The derived class does not support the OnRequest operation.");
}
public Message Request(Message message, TimeSpan timeout)
{
return this.Request(message, timeout, this.DefaultMaskingMode);
}
public Message Request(Message message, TimeSpan timeout, MaskingMode maskingMode)
{
if (!this.ValidateOutputOperation(message, timeout, maskingMode))
{
return null;
}
bool autoAborted = false;
try
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
TChannel channel;
if (!this.Synchronizer.TryGetChannelForOutput(timeoutHelper.RemainingTime(), maskingMode,
out channel))
{
if (!ReliableChannelBinderHelper.MaskHandled(maskingMode))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TimeoutException(SR.GetString(SR.TimeoutOnRequest, timeout)));
}
return null;
}
if (channel == null)
{
return null;
}
try
{
return this.OnRequest(channel, message, timeoutHelper.RemainingTime(),
maskingMode);
}
finally
{
autoAborted = this.Synchronizer.Aborting;
this.Synchronizer.ReturnChannel();
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
if (!this.HandleException(e, maskingMode, autoAborted))
{
throw;
}
else
{
return null;
}
}
}
protected override bool TryGetChannel(TimeSpan timeout)
{
CommunicationState currentState = this.State;
TChannel channel = null;
if ((currentState == CommunicationState.Created)
|| (currentState == CommunicationState.Opening)
|| (currentState == CommunicationState.Opened))
{
channel = this.factory.CreateChannel(this.to, this.via);
if (!this.Synchronizer.SetChannel(channel))
{
channel.Abort();
}
}
else
{
channel = null;
}
return true;
}
abstract class DuplexClientReliableChannelBinder<TDuplexChannel>
: ClientReliableChannelBinder<TDuplexChannel>
where TDuplexChannel : class, IDuplexChannel
{
public DuplexClientReliableChannelBinder(EndpointAddress to, Uri via,
IChannelFactory<TDuplexChannel> factory, MaskingMode maskingMode, TolerateFaultsMode faultMode,
ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
: base(to, via, factory, maskingMode, faultMode, channelParameters, defaultCloseTimeout,
defaultSendTimeout)
{
}
public override EndpointAddress LocalAddress
{
get
{
IDuplexChannel channel = this.Synchronizer.CurrentChannel;
if (channel == null)
return null;
else
return channel.LocalAddress;
}
}
public override EndpointAddress RemoteAddress
{
get
{
IDuplexChannel channel = this.Synchronizer.CurrentChannel;
if (channel == null)
return null;
else
return channel.RemoteAddress;
}
}
protected override IAsyncResult OnBeginSend(TDuplexChannel channel, Message message,
TimeSpan timeout, AsyncCallback callback, object state)
{
return channel.BeginSend(message, timeout, callback, state);
}
protected override IAsyncResult OnBeginTryReceive(TDuplexChannel channel,
TimeSpan timeout, AsyncCallback callback, object state)
{
return channel.BeginTryReceive(timeout, callback, state);
}
protected override void OnEndSend(TDuplexChannel channel, IAsyncResult result)
{
channel.EndSend(result);
}
protected override bool OnEndTryReceive(TDuplexChannel channel, IAsyncResult result,
out RequestContext requestContext)
{
Message message;
bool success = channel.EndTryReceive(result, out message);
if (success && message == null)
{
this.OnReadNullMessage();
}
requestContext = this.WrapMessage(message);
return success;
}
protected virtual void OnReadNullMessage()
{
}
protected override void OnSend(TDuplexChannel channel, Message message,
TimeSpan timeout)
{
channel.Send(message, timeout);
}
protected override bool OnTryReceive(TDuplexChannel channel, TimeSpan timeout,
out RequestContext requestContext)
{
Message message;
bool success = channel.TryReceive(timeout, out message);
if (success && message == null)
{
this.OnReadNullMessage();
}
requestContext = this.WrapMessage(message);
return success;
}
}
sealed class DuplexClientReliableChannelBinder
: DuplexClientReliableChannelBinder<IDuplexChannel>
{
public DuplexClientReliableChannelBinder(EndpointAddress to, Uri via,
IChannelFactory<IDuplexChannel> factory, MaskingMode maskingMode,
ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
: base(to, via, factory, maskingMode, TolerateFaultsMode.Never, channelParameters,
defaultCloseTimeout, defaultSendTimeout)
{
}
public override bool HasSession
{
get
{
return false;
}
}
public override ISession GetInnerSession()
{
return null;
}
protected override bool HasSecuritySession(IDuplexChannel channel)
{
return false;
}
}
sealed class DuplexSessionClientReliableChannelBinder
: DuplexClientReliableChannelBinder<IDuplexSessionChannel>
{
public DuplexSessionClientReliableChannelBinder(EndpointAddress to, Uri via,
IChannelFactory<IDuplexSessionChannel> factory, MaskingMode maskingMode, TolerateFaultsMode faultMode,
ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
: base(to, via, factory, maskingMode, faultMode, channelParameters, defaultCloseTimeout,
defaultSendTimeout)
{
}
public override bool HasSession
{
get
{
return true;
}
}
public override ISession GetInnerSession()
{
return this.Synchronizer.CurrentChannel.Session;
}
protected override IAsyncResult BeginCloseChannel(IDuplexSessionChannel channel,
TimeSpan timeout, AsyncCallback callback, object state)
{
return ReliableChannelBinderHelper.BeginCloseDuplexSessionChannel(this, channel,
timeout, callback, state);
}
protected override void CloseChannel(IDuplexSessionChannel channel, TimeSpan timeout)
{
ReliableChannelBinderHelper.CloseDuplexSessionChannel(this, channel, timeout);
}
protected override void EndCloseChannel(IDuplexSessionChannel channel,
IAsyncResult result)
{
ReliableChannelBinderHelper.EndCloseDuplexSessionChannel(channel, result);
}
protected override bool HasSecuritySession(IDuplexSessionChannel channel)
{
return channel.Session is ISecuritySession;
}
protected override void OnReadNullMessage()
{
this.Synchronizer.OnReadEof();
}
}
abstract class RequestClientReliableChannelBinder<TRequestChannel>
: ClientReliableChannelBinder<TRequestChannel>
where TRequestChannel : class, IRequestChannel
{
InputQueue<Message> inputMessages;
public RequestClientReliableChannelBinder(EndpointAddress to, Uri via,
IChannelFactory<TRequestChannel> factory, MaskingMode maskingMode, TolerateFaultsMode faultMode,
ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
: base(to, via, factory, maskingMode, faultMode, channelParameters, defaultCloseTimeout,
defaultSendTimeout)
{
}
public override IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback,
object state)
{
return this.GetInputMessages().BeginDequeue(timeout, callback, state);
}
public override bool EndTryReceive(IAsyncResult result,
out RequestContext requestContext)
{
Message message;
bool success = this.GetInputMessages().EndDequeue(result, out message);
requestContext = this.WrapMessage(message);
return success;
}
protected void EnqueueMessageIfNotNull(Message message)
{
if (message != null)
{
this.GetInputMessages().EnqueueAndDispatch(message);
}
}
InputQueue<Message> GetInputMessages()
{
lock (this.ThisLock)
{
if (this.State == CommunicationState.Created)
{
throw Fx.AssertAndThrow("The method GetInputMessages() cannot be called when the binder is in the Created state.");
}
if (this.State == CommunicationState.Opening)
{
throw Fx.AssertAndThrow("The method GetInputMessages() cannot be called when the binder is in the Opening state.");
}
if (this.inputMessages == null)
{
this.inputMessages = TraceUtility.CreateInputQueue<Message>();
}
}
return this.inputMessages;
}
public override EndpointAddress LocalAddress
{
get
{
return EndpointAddress.AnonymousAddress;
}
}
public override EndpointAddress RemoteAddress
{
get
{
IRequestChannel channel = this.Synchronizer.CurrentChannel;
if (channel == null)
return null;
else
return channel.RemoteAddress;
}
}
protected override IAsyncResult OnBeginRequest(TRequestChannel channel,
Message message, TimeSpan timeout, MaskingMode maskingMode,
AsyncCallback callback, object state)
{
return channel.BeginRequest(message, timeout, callback, state);
}
protected override IAsyncResult OnBeginSend(TRequestChannel channel, Message message,
TimeSpan timeout, AsyncCallback callback, object state)
{
return channel.BeginRequest(message, timeout, callback, state);
}
protected override Message OnEndRequest(TRequestChannel channel,
MaskingMode maskingMode, IAsyncResult result)
{
return channel.EndRequest(result);
}
protected override void OnEndSend(TRequestChannel channel, IAsyncResult result)
{
Message message = channel.EndRequest(result);
this.EnqueueMessageIfNotNull(message);
}
protected override Message OnRequest(TRequestChannel channel, Message message,
TimeSpan timeout, MaskingMode maskingMode)
{
return channel.Request(message, timeout);
}
protected override void OnSend(TRequestChannel channel, Message message,
TimeSpan timeout)
{
message = channel.Request(message, timeout);
this.EnqueueMessageIfNotNull(message);
}
protected override void OnShutdown()
{
if (this.inputMessages != null)
{
this.inputMessages.Close();
}
}
public override bool TryReceive(TimeSpan timeout, out RequestContext requestContext)
{
Message message;
bool success = this.GetInputMessages().Dequeue(timeout, out message);
requestContext = this.WrapMessage(message);
return success;
}
}
sealed class RequestAsyncResult
: ReliableChannelBinder<TChannel>.OutputAsyncResult<ClientReliableChannelBinder<TChannel>>
{
Message reply;
public RequestAsyncResult(ClientReliableChannelBinder<TChannel> binder,
AsyncCallback callback, object state)
: base(binder, callback, state)
{
}
protected override IAsyncResult BeginOutput(
ClientReliableChannelBinder<TChannel> binder, TChannel channel, Message message,
TimeSpan timeout, MaskingMode maskingMode, AsyncCallback callback, object state)
{
return binder.OnBeginRequest(channel, message, timeout, maskingMode, callback,
state);
}
public static Message End(IAsyncResult result)
{
RequestAsyncResult requestResult = AsyncResult.End<RequestAsyncResult>(result);
return requestResult.reply;
}
protected override void EndOutput(ClientReliableChannelBinder<TChannel> binder,
TChannel channel, MaskingMode maskingMode, IAsyncResult result)
{
this.reply = binder.OnEndRequest(channel, maskingMode, result);
}
protected override string GetTimeoutString(TimeSpan timeout)
{
return SR.GetString(SR.TimeoutOnRequest, timeout);
}
}
sealed class RequestClientReliableChannelBinder
: RequestClientReliableChannelBinder<IRequestChannel>
{
public RequestClientReliableChannelBinder(EndpointAddress to, Uri via,
IChannelFactory<IRequestChannel> factory, MaskingMode maskingMode,
ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
: base(to, via, factory, maskingMode, TolerateFaultsMode.Never, channelParameters,
defaultCloseTimeout, defaultSendTimeout)
{
}
public override bool HasSession
{
get
{
return false;
}
}
public override ISession GetInnerSession()
{
return null;
}
protected override bool HasSecuritySession(IRequestChannel channel)
{
return false;
}
}
sealed class RequestSessionClientReliableChannelBinder
: RequestClientReliableChannelBinder<IRequestSessionChannel>
{
public RequestSessionClientReliableChannelBinder(EndpointAddress to, Uri via,
IChannelFactory<IRequestSessionChannel> factory, MaskingMode maskingMode, TolerateFaultsMode faultMode,
ChannelParameterCollection channelParameters,
TimeSpan defaultCloseTimeout, TimeSpan defaultSendTimeout)
: base(to, via, factory, maskingMode, faultMode, channelParameters, defaultCloseTimeout,
defaultSendTimeout)
{
}
public override bool HasSession
{
get
{
return true;
}
}
public override ISession GetInnerSession()
{
return this.Synchronizer.CurrentChannel.Session;
}
protected override bool HasSecuritySession(IRequestSessionChannel channel)
{
return channel.Session is ISecuritySession;
}
}
}
}