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
692 lines
28 KiB
C#
692 lines
28 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.Runtime.Remoting;
|
|
using System.Security;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Dispatcher;
|
|
|
|
abstract class ServiceChannelFactory : ChannelFactoryBase
|
|
{
|
|
string bindingName;
|
|
List<IChannel> channelsList;
|
|
ClientRuntime clientRuntime;
|
|
RequestReplyCorrelator requestReplyCorrelator = new RequestReplyCorrelator();
|
|
IDefaultCommunicationTimeouts timeouts;
|
|
MessageVersion messageVersion;
|
|
|
|
public ServiceChannelFactory(ClientRuntime clientRuntime, Binding binding)
|
|
: base()
|
|
{
|
|
if (clientRuntime == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("clientRuntime");
|
|
}
|
|
|
|
this.bindingName = binding.Name;
|
|
this.channelsList = new List<IChannel>();
|
|
this.clientRuntime = clientRuntime;
|
|
this.timeouts = new DefaultCommunicationTimeouts(binding);
|
|
this.messageVersion = binding.MessageVersion;
|
|
}
|
|
|
|
public ClientRuntime ClientRuntime
|
|
{
|
|
get
|
|
{
|
|
this.ThrowIfDisposed();
|
|
return this.clientRuntime;
|
|
}
|
|
}
|
|
|
|
internal RequestReplyCorrelator RequestReplyCorrelator
|
|
{
|
|
get
|
|
{
|
|
ThrowIfDisposed();
|
|
return this.requestReplyCorrelator;
|
|
}
|
|
}
|
|
|
|
protected override TimeSpan DefaultCloseTimeout
|
|
{
|
|
get { return this.timeouts.CloseTimeout; }
|
|
}
|
|
|
|
protected override TimeSpan DefaultReceiveTimeout
|
|
{
|
|
get { return this.timeouts.ReceiveTimeout; }
|
|
}
|
|
|
|
protected override TimeSpan DefaultOpenTimeout
|
|
{
|
|
get { return this.timeouts.OpenTimeout; }
|
|
}
|
|
|
|
protected override TimeSpan DefaultSendTimeout
|
|
{
|
|
get { return this.timeouts.SendTimeout; }
|
|
}
|
|
|
|
public MessageVersion MessageVersion
|
|
{
|
|
get { return this.messageVersion; }
|
|
}
|
|
|
|
// special overload for security only
|
|
public static ServiceChannelFactory BuildChannelFactory(ChannelBuilder channelBuilder, ClientRuntime clientRuntime)
|
|
{
|
|
if (channelBuilder.CanBuildChannelFactory<IDuplexChannel>())
|
|
{
|
|
return new ServiceChannelFactoryOverDuplex(channelBuilder.BuildChannelFactory<IDuplexChannel>(), clientRuntime,
|
|
channelBuilder.Binding);
|
|
}
|
|
else if (channelBuilder.CanBuildChannelFactory<IDuplexSessionChannel>())
|
|
{
|
|
return new ServiceChannelFactoryOverDuplexSession(channelBuilder.BuildChannelFactory<IDuplexSessionChannel>(), clientRuntime, channelBuilder.Binding, false);
|
|
}
|
|
else
|
|
{
|
|
return new ServiceChannelFactoryOverRequestSession(channelBuilder.BuildChannelFactory<IRequestSessionChannel>(), clientRuntime, channelBuilder.Binding, false);
|
|
}
|
|
}
|
|
|
|
public static ServiceChannelFactory BuildChannelFactory(ServiceEndpoint serviceEndpoint)
|
|
{
|
|
return BuildChannelFactory(serviceEndpoint, false);
|
|
}
|
|
|
|
public static ServiceChannelFactory BuildChannelFactory(ServiceEndpoint serviceEndpoint, bool useActiveAutoClose)
|
|
{
|
|
if (serviceEndpoint == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceEndpoint");
|
|
}
|
|
|
|
serviceEndpoint.EnsureInvariants();
|
|
serviceEndpoint.ValidateForClient();
|
|
|
|
ChannelRequirements requirements;
|
|
ContractDescription contractDescription = serviceEndpoint.Contract;
|
|
ChannelRequirements.ComputeContractRequirements(contractDescription, out requirements);
|
|
|
|
BindingParameterCollection parameters;
|
|
ClientRuntime clientRuntime = DispatcherBuilder.BuildProxyBehavior(serviceEndpoint, out parameters);
|
|
|
|
Binding binding = serviceEndpoint.Binding;
|
|
Type[] requiredChannels = ChannelRequirements.ComputeRequiredChannels(ref requirements);
|
|
|
|
CustomBinding customBinding = new CustomBinding(binding);
|
|
BindingContext context = new BindingContext(customBinding, parameters);
|
|
|
|
InternalDuplexBindingElement internalDuplexBindingElement = null;
|
|
InternalDuplexBindingElement.AddDuplexFactorySupport(context, ref internalDuplexBindingElement);
|
|
|
|
customBinding = new CustomBinding(context.RemainingBindingElements);
|
|
customBinding.CopyTimeouts(serviceEndpoint.Binding);
|
|
|
|
foreach (Type type in requiredChannels)
|
|
{
|
|
if (type == typeof(IOutputChannel) && customBinding.CanBuildChannelFactory<IOutputChannel>(parameters))
|
|
{
|
|
return new ServiceChannelFactoryOverOutput(customBinding.BuildChannelFactory<IOutputChannel>(parameters), clientRuntime, binding);
|
|
}
|
|
|
|
if (type == typeof(IRequestChannel) && customBinding.CanBuildChannelFactory<IRequestChannel>(parameters))
|
|
{
|
|
return new ServiceChannelFactoryOverRequest(customBinding.BuildChannelFactory<IRequestChannel>(parameters), clientRuntime, binding);
|
|
}
|
|
|
|
if (type == typeof(IDuplexChannel) && customBinding.CanBuildChannelFactory<IDuplexChannel>(parameters))
|
|
{
|
|
if (requirements.usesReply &&
|
|
binding.CreateBindingElements().Find<TransportBindingElement>().ManualAddressing)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR.GetString(SR.CantCreateChannelWithManualAddressing)));
|
|
}
|
|
|
|
return new ServiceChannelFactoryOverDuplex(customBinding.BuildChannelFactory<IDuplexChannel>(parameters), clientRuntime, binding);
|
|
}
|
|
|
|
if (type == typeof(IOutputSessionChannel) && customBinding.CanBuildChannelFactory<IOutputSessionChannel>(parameters))
|
|
{
|
|
return new ServiceChannelFactoryOverOutputSession(customBinding.BuildChannelFactory<IOutputSessionChannel>(parameters), clientRuntime, binding, false);
|
|
}
|
|
|
|
if (type == typeof(IRequestSessionChannel) && customBinding.CanBuildChannelFactory<IRequestSessionChannel>(parameters))
|
|
{
|
|
return new ServiceChannelFactoryOverRequestSession(customBinding.BuildChannelFactory<IRequestSessionChannel>(parameters), clientRuntime, binding, false);
|
|
}
|
|
|
|
if (type == typeof(IDuplexSessionChannel) && customBinding.CanBuildChannelFactory<IDuplexSessionChannel>(parameters))
|
|
{
|
|
if (requirements.usesReply &&
|
|
binding.CreateBindingElements().Find<TransportBindingElement>().ManualAddressing)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR.GetString(SR.CantCreateChannelWithManualAddressing)));
|
|
}
|
|
|
|
return new ServiceChannelFactoryOverDuplexSession(customBinding.BuildChannelFactory<IDuplexSessionChannel>(parameters), clientRuntime, binding, useActiveAutoClose);
|
|
}
|
|
}
|
|
|
|
foreach (Type type in requiredChannels)
|
|
{
|
|
// For SessionMode.Allowed or SessionMode.NotAllowed we will accept session-ful variants as well
|
|
if (type == typeof(IOutputChannel) && customBinding.CanBuildChannelFactory<IOutputSessionChannel>(parameters))
|
|
{
|
|
return new ServiceChannelFactoryOverOutputSession(customBinding.BuildChannelFactory<IOutputSessionChannel>(parameters), clientRuntime, binding, true);
|
|
}
|
|
|
|
if (type == typeof(IRequestChannel) && customBinding.CanBuildChannelFactory<IRequestSessionChannel>(parameters))
|
|
{
|
|
return new ServiceChannelFactoryOverRequestSession(customBinding.BuildChannelFactory<IRequestSessionChannel>(parameters), clientRuntime, binding, true);
|
|
}
|
|
|
|
// and for SessionMode.Required, it is possible that the InstanceContextProvider is handling the session management, so
|
|
// accept datagram variants if that is the case
|
|
if (type == typeof(IRequestSessionChannel) && customBinding.CanBuildChannelFactory<IRequestChannel>(parameters)
|
|
&& customBinding.GetProperty<IContextSessionProvider>(parameters) != null)
|
|
{
|
|
return new ServiceChannelFactoryOverRequest(customBinding.BuildChannelFactory<IRequestChannel>(parameters), clientRuntime, binding);
|
|
}
|
|
}
|
|
|
|
// we put a lot of work into creating a good error message, as this is a common case
|
|
Dictionary<Type, byte> supportedChannels = new Dictionary<Type, byte>();
|
|
if (customBinding.CanBuildChannelFactory<IOutputChannel>(parameters))
|
|
{
|
|
supportedChannels.Add(typeof(IOutputChannel), 0);
|
|
}
|
|
if (customBinding.CanBuildChannelFactory<IRequestChannel>(parameters))
|
|
{
|
|
supportedChannels.Add(typeof(IRequestChannel), 0);
|
|
}
|
|
if (customBinding.CanBuildChannelFactory<IDuplexChannel>(parameters))
|
|
{
|
|
supportedChannels.Add(typeof(IDuplexChannel), 0);
|
|
}
|
|
if (customBinding.CanBuildChannelFactory<IOutputSessionChannel>(parameters))
|
|
{
|
|
supportedChannels.Add(typeof(IOutputSessionChannel), 0);
|
|
}
|
|
if (customBinding.CanBuildChannelFactory<IRequestSessionChannel>(parameters))
|
|
{
|
|
supportedChannels.Add(typeof(IRequestSessionChannel), 0);
|
|
}
|
|
if (customBinding.CanBuildChannelFactory<IDuplexSessionChannel>(parameters))
|
|
{
|
|
supportedChannels.Add(typeof(IDuplexSessionChannel), 0);
|
|
}
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ChannelRequirements.CantCreateChannelException(
|
|
supportedChannels.Keys, requiredChannels, binding.Name));
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
IChannel channel = null;
|
|
|
|
lock (ThisLock)
|
|
{
|
|
channel = (channelsList.Count > 0) ? channelsList[channelsList.Count - 1] : null;
|
|
}
|
|
|
|
while (channel != null)
|
|
{
|
|
channel.Abort();
|
|
|
|
lock (ThisLock)
|
|
{
|
|
channelsList.Remove(channel);
|
|
channel = (channelsList.Count > 0) ? channelsList[channelsList.Count - 1] : null;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
while (true)
|
|
{
|
|
int count;
|
|
IChannel channel;
|
|
lock (ThisLock)
|
|
{
|
|
count = channelsList.Count;
|
|
if (count == 0)
|
|
return;
|
|
channel = channelsList[0];
|
|
}
|
|
channel.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
List<ICommunicationObject> objectList;
|
|
lock (ThisLock)
|
|
{
|
|
objectList = new List<ICommunicationObject>();
|
|
for (int index = 0; index < channelsList.Count; index++)
|
|
objectList.Add(channelsList[index]);
|
|
}
|
|
return new CloseCollectionAsyncResult(timeout, callback, state, objectList);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
CloseCollectionAsyncResult.End(result);
|
|
}
|
|
|
|
protected override void OnOpened()
|
|
{
|
|
base.OnOpened();
|
|
this.clientRuntime.LockDownProperties();
|
|
}
|
|
|
|
public void ChannelCreated(IChannel channel)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceVerbose)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.ChannelCreated,
|
|
SR.GetString(SR.TraceCodeChannelCreated, TraceUtility.CreateSourceString(channel)), this);
|
|
}
|
|
lock (ThisLock)
|
|
{
|
|
ThrowIfDisposed();
|
|
channelsList.Add(channel);
|
|
}
|
|
}
|
|
|
|
public void ChannelDisposed(IChannel channel)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceVerbose)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.ChannelDisposed,
|
|
SR.GetString(SR.TraceCodeChannelDisposed, TraceUtility.CreateSourceString(channel)),
|
|
this);
|
|
}
|
|
lock (ThisLock)
|
|
{
|
|
channelsList.Remove(channel);
|
|
}
|
|
}
|
|
|
|
public virtual ServiceChannel CreateServiceChannel(EndpointAddress address, Uri via)
|
|
{
|
|
IChannelBinder binder = this.CreateInnerChannelBinder(address, via);
|
|
ServiceChannel serviceChannel = new ServiceChannel(this, binder);
|
|
|
|
if (binder is DuplexChannelBinder)
|
|
{
|
|
DuplexChannelBinder duplexChannelBinder = binder as DuplexChannelBinder;
|
|
duplexChannelBinder.ChannelHandler = new ChannelHandler(this.messageVersion, binder, serviceChannel);
|
|
duplexChannelBinder.DefaultCloseTimeout = this.DefaultCloseTimeout;
|
|
duplexChannelBinder.DefaultSendTimeout = this.DefaultSendTimeout;
|
|
duplexChannelBinder.IdentityVerifier = this.clientRuntime.IdentityVerifier;
|
|
}
|
|
|
|
return serviceChannel;
|
|
}
|
|
|
|
public TChannel CreateChannel<TChannel>(EndpointAddress address)
|
|
{
|
|
return this.CreateChannel<TChannel>(address, null);
|
|
}
|
|
|
|
public TChannel CreateChannel<TChannel>(EndpointAddress address, Uri via)
|
|
{
|
|
if (!this.CanCreateChannel<TChannel>())
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR.GetString(SR.CouldnTCreateChannelForChannelType2, this.bindingName, typeof(TChannel).Name)));
|
|
}
|
|
|
|
return (TChannel)this.CreateChannel(typeof(TChannel), address, via);
|
|
}
|
|
|
|
public abstract bool CanCreateChannel<TChannel>();
|
|
|
|
public object CreateChannel(Type channelType, EndpointAddress address)
|
|
{
|
|
return this.CreateChannel(channelType, address, null);
|
|
}
|
|
|
|
public object CreateChannel(Type channelType, EndpointAddress address, Uri via)
|
|
{
|
|
if (via == null)
|
|
{
|
|
via = this.ClientRuntime.Via;
|
|
|
|
if (via == null)
|
|
{
|
|
via = address.Uri;
|
|
}
|
|
}
|
|
|
|
ServiceChannel serviceChannel = this.CreateServiceChannel(address, via);
|
|
|
|
serviceChannel.Proxy = CreateProxy(channelType, channelType, MessageDirection.Input, serviceChannel);
|
|
|
|
serviceChannel.ClientRuntime.GetRuntime().InitializeChannel((IClientChannel)serviceChannel.Proxy);
|
|
OperationContext current = OperationContext.Current;
|
|
if ((current != null) && (current.InstanceContext != null))
|
|
{
|
|
current.InstanceContext.WmiChannels.Add((IChannel)serviceChannel.Proxy);
|
|
serviceChannel.WmiInstanceContext = current.InstanceContext;
|
|
}
|
|
|
|
return serviceChannel.Proxy;
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Constructs a ServiceChannelProxy, which is Critical.",
|
|
Safe = "Returns the TP, but does not return the RealProxy -- caller can't get from TP to RP without an elevation.")]
|
|
[SecuritySafeCritical]
|
|
internal static object CreateProxy(Type interfaceType, Type proxiedType, MessageDirection direction, ServiceChannel serviceChannel)
|
|
{
|
|
if (!proxiedType.IsInterface)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString("SFxChannelFactoryTypeMustBeInterface")));
|
|
}
|
|
ServiceChannelProxy proxy = new ServiceChannelProxy(interfaceType, proxiedType, direction, serviceChannel);
|
|
return proxy.GetTransparentProxy();
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Calls LinkDemand method RemotingServices.GetRealProxy and access critical class ServiceChannelProxy.",
|
|
Safe = "Gets the ServiceChannel (which is not critical) and discards the RealProxy.")]
|
|
[SecuritySafeCritical]
|
|
internal static ServiceChannel GetServiceChannel(object transparentProxy)
|
|
{
|
|
IChannelBaseProxy cb = transparentProxy as IChannelBaseProxy;
|
|
if (cb != null)
|
|
return cb.GetServiceChannel();
|
|
|
|
ServiceChannelProxy proxy = RemotingServices.GetRealProxy(transparentProxy) as ServiceChannelProxy;
|
|
|
|
if (proxy != null)
|
|
return proxy.GetServiceChannel();
|
|
else
|
|
return null;
|
|
}
|
|
|
|
protected abstract IChannelBinder CreateInnerChannelBinder(EndpointAddress address, Uri via);
|
|
|
|
abstract class TypedServiceChannelFactory<TChannel> : ServiceChannelFactory
|
|
where TChannel : class, IChannel
|
|
{
|
|
IChannelFactory<TChannel> innerChannelFactory;
|
|
|
|
protected TypedServiceChannelFactory(IChannelFactory<TChannel> innerChannelFactory,
|
|
ClientRuntime clientRuntime, Binding binding)
|
|
: base(clientRuntime, binding)
|
|
{
|
|
this.innerChannelFactory = innerChannelFactory;
|
|
}
|
|
|
|
protected IChannelFactory<TChannel> InnerChannelFactory
|
|
{
|
|
get { return this.innerChannelFactory; }
|
|
}
|
|
|
|
protected override void OnAbort()
|
|
{
|
|
base.OnAbort();
|
|
this.innerChannelFactory.Abort();
|
|
}
|
|
|
|
protected override void OnOpen(TimeSpan timeout)
|
|
{
|
|
this.innerChannelFactory.Open(timeout);
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return this.innerChannelFactory.BeginOpen(timeout, callback, state);
|
|
}
|
|
|
|
protected override void OnEndOpen(IAsyncResult result)
|
|
{
|
|
this.innerChannelFactory.EndOpen(result);
|
|
}
|
|
|
|
protected override void OnClose(TimeSpan timeout)
|
|
{
|
|
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
|
|
base.OnClose(timeoutHelper.RemainingTime());
|
|
this.innerChannelFactory.Close(timeoutHelper.RemainingTime());
|
|
}
|
|
|
|
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
return new ChainedAsyncResult(timeout, callback, state, base.OnBeginClose, base.OnEndClose,
|
|
this.innerChannelFactory.BeginClose, this.innerChannelFactory.EndClose);
|
|
}
|
|
|
|
protected override void OnEndClose(IAsyncResult result)
|
|
{
|
|
ChainedAsyncResult.End(result);
|
|
}
|
|
|
|
public override T GetProperty<T>()
|
|
{
|
|
if (typeof(T) == typeof(TypedServiceChannelFactory<TChannel>))
|
|
{
|
|
return (T)(object)this;
|
|
}
|
|
|
|
T baseProperty = base.GetProperty<T>();
|
|
if (baseProperty != null)
|
|
{
|
|
return baseProperty;
|
|
}
|
|
|
|
return this.innerChannelFactory.GetProperty<T>();
|
|
}
|
|
}
|
|
|
|
class ServiceChannelFactoryOverOutput : TypedServiceChannelFactory<IOutputChannel>
|
|
{
|
|
public ServiceChannelFactoryOverOutput(IChannelFactory<IOutputChannel> innerChannelFactory, ClientRuntime clientRuntime, Binding binding)
|
|
: base(innerChannelFactory, clientRuntime, binding)
|
|
{
|
|
}
|
|
|
|
protected override IChannelBinder CreateInnerChannelBinder(EndpointAddress to, Uri via)
|
|
{
|
|
return new OutputChannelBinder(this.InnerChannelFactory.CreateChannel(to, via));
|
|
}
|
|
|
|
public override bool CanCreateChannel<TChannel>()
|
|
{
|
|
return (typeof(TChannel) == typeof(IOutputChannel)
|
|
|| typeof(TChannel) == typeof(IRequestChannel));
|
|
}
|
|
}
|
|
|
|
class ServiceChannelFactoryOverDuplex : TypedServiceChannelFactory<IDuplexChannel>
|
|
{
|
|
public ServiceChannelFactoryOverDuplex(IChannelFactory<IDuplexChannel> innerChannelFactory, ClientRuntime clientRuntime, Binding binding)
|
|
: base(innerChannelFactory, clientRuntime, binding)
|
|
{
|
|
}
|
|
|
|
protected override IChannelBinder CreateInnerChannelBinder(EndpointAddress to, Uri via)
|
|
{
|
|
return new DuplexChannelBinder(this.InnerChannelFactory.CreateChannel(to, via), this.RequestReplyCorrelator);
|
|
}
|
|
|
|
public override bool CanCreateChannel<TChannel>()
|
|
{
|
|
return (typeof(TChannel) == typeof(IOutputChannel)
|
|
|| typeof(TChannel) == typeof(IRequestChannel)
|
|
|| typeof(TChannel) == typeof(IDuplexChannel));
|
|
}
|
|
}
|
|
|
|
class ServiceChannelFactoryOverRequest : TypedServiceChannelFactory<IRequestChannel>
|
|
{
|
|
public ServiceChannelFactoryOverRequest(IChannelFactory<IRequestChannel> innerChannelFactory, ClientRuntime clientRuntime, Binding binding)
|
|
: base(innerChannelFactory, clientRuntime, binding)
|
|
{
|
|
}
|
|
|
|
protected override IChannelBinder CreateInnerChannelBinder(EndpointAddress to, Uri via)
|
|
{
|
|
return new RequestChannelBinder(this.InnerChannelFactory.CreateChannel(to, via));
|
|
}
|
|
|
|
public override bool CanCreateChannel<TChannel>()
|
|
{
|
|
return (typeof(TChannel) == typeof(IOutputChannel)
|
|
|| typeof(TChannel) == typeof(IRequestChannel));
|
|
}
|
|
}
|
|
|
|
class ServiceChannelFactoryOverOutputSession : TypedServiceChannelFactory<IOutputSessionChannel>
|
|
{
|
|
bool datagramAdapter;
|
|
public ServiceChannelFactoryOverOutputSession(IChannelFactory<IOutputSessionChannel> innerChannelFactory, ClientRuntime clientRuntime, Binding binding, bool datagramAdapter)
|
|
: base(innerChannelFactory, clientRuntime, binding)
|
|
{
|
|
this.datagramAdapter = datagramAdapter;
|
|
}
|
|
|
|
protected override IChannelBinder CreateInnerChannelBinder(EndpointAddress to, Uri via)
|
|
{
|
|
IOutputChannel channel;
|
|
|
|
if (this.datagramAdapter)
|
|
{
|
|
channel = DatagramAdapter.GetOutputChannel(
|
|
delegate() { return this.InnerChannelFactory.CreateChannel(to, via); },
|
|
timeouts);
|
|
}
|
|
else
|
|
{
|
|
channel = this.InnerChannelFactory.CreateChannel(to, via);
|
|
}
|
|
|
|
return new OutputChannelBinder(channel);
|
|
}
|
|
|
|
public override bool CanCreateChannel<TChannel>()
|
|
{
|
|
return (typeof(TChannel) == typeof(IOutputChannel)
|
|
|| typeof(TChannel) == typeof(IOutputSessionChannel)
|
|
|| typeof(TChannel) == typeof(IRequestChannel)
|
|
|| typeof(TChannel) == typeof(IRequestSessionChannel));
|
|
}
|
|
}
|
|
|
|
class ServiceChannelFactoryOverDuplexSession : TypedServiceChannelFactory<IDuplexSessionChannel>
|
|
{
|
|
bool useActiveAutoClose;
|
|
|
|
public ServiceChannelFactoryOverDuplexSession(IChannelFactory<IDuplexSessionChannel> innerChannelFactory, ClientRuntime clientRuntime, Binding binding, bool useActiveAutoClose)
|
|
: base(innerChannelFactory, clientRuntime, binding)
|
|
{
|
|
this.useActiveAutoClose = useActiveAutoClose;
|
|
}
|
|
|
|
protected override IChannelBinder CreateInnerChannelBinder(EndpointAddress to, Uri via)
|
|
{
|
|
return new DuplexChannelBinder(this.InnerChannelFactory.CreateChannel(to, via), this.RequestReplyCorrelator, useActiveAutoClose);
|
|
}
|
|
|
|
public override bool CanCreateChannel<TChannel>()
|
|
{
|
|
return (typeof(TChannel) == typeof(IOutputChannel)
|
|
|| typeof(TChannel) == typeof(IRequestChannel)
|
|
|| typeof(TChannel) == typeof(IDuplexChannel)
|
|
|| typeof(TChannel) == typeof(IOutputSessionChannel)
|
|
|| typeof(TChannel) == typeof(IRequestSessionChannel)
|
|
|| typeof(TChannel) == typeof(IDuplexSessionChannel));
|
|
}
|
|
}
|
|
|
|
class ServiceChannelFactoryOverRequestSession : TypedServiceChannelFactory<IRequestSessionChannel>
|
|
{
|
|
bool datagramAdapter = false;
|
|
|
|
public ServiceChannelFactoryOverRequestSession(IChannelFactory<IRequestSessionChannel> innerChannelFactory, ClientRuntime clientRuntime, Binding binding, bool datagramAdapter)
|
|
: base(innerChannelFactory, clientRuntime, binding)
|
|
{
|
|
this.datagramAdapter = datagramAdapter;
|
|
}
|
|
|
|
protected override IChannelBinder CreateInnerChannelBinder(EndpointAddress to, Uri via)
|
|
{
|
|
IRequestChannel channel;
|
|
|
|
if (this.datagramAdapter)
|
|
{
|
|
channel = DatagramAdapter.GetRequestChannel(
|
|
delegate() { return this.InnerChannelFactory.CreateChannel(to, via); },
|
|
this.timeouts);
|
|
}
|
|
else
|
|
{
|
|
channel = this.InnerChannelFactory.CreateChannel(to, via);
|
|
}
|
|
|
|
return new RequestChannelBinder(channel);
|
|
}
|
|
|
|
public override bool CanCreateChannel<TChannel>()
|
|
{
|
|
return (typeof(TChannel) == typeof(IOutputChannel)
|
|
|| typeof(TChannel) == typeof(IOutputSessionChannel)
|
|
|| typeof(TChannel) == typeof(IRequestChannel)
|
|
|| typeof(TChannel) == typeof(IRequestSessionChannel));
|
|
}
|
|
}
|
|
|
|
class DefaultCommunicationTimeouts : IDefaultCommunicationTimeouts
|
|
{
|
|
TimeSpan closeTimeout;
|
|
TimeSpan openTimeout;
|
|
TimeSpan receiveTimeout;
|
|
TimeSpan sendTimeout;
|
|
|
|
public DefaultCommunicationTimeouts(IDefaultCommunicationTimeouts timeouts)
|
|
{
|
|
this.closeTimeout = timeouts.CloseTimeout;
|
|
this.openTimeout = timeouts.OpenTimeout;
|
|
this.receiveTimeout = timeouts.ReceiveTimeout;
|
|
this.sendTimeout = timeouts.SendTimeout;
|
|
}
|
|
|
|
public TimeSpan CloseTimeout
|
|
{
|
|
get { return this.closeTimeout; }
|
|
}
|
|
|
|
public TimeSpan OpenTimeout
|
|
{
|
|
get { return this.openTimeout; }
|
|
}
|
|
|
|
public TimeSpan ReceiveTimeout
|
|
{
|
|
get { return this.receiveTimeout; }
|
|
}
|
|
|
|
public TimeSpan SendTimeout
|
|
{
|
|
get { return this.sendTimeout; }
|
|
}
|
|
}
|
|
}
|
|
}
|