public static void AddDuplexListenerSupport(CustomBinding binding, ref InternalDuplexBindingElement internalDuplexBindingElement)
{
if (binding.CanBuildChannelListener <IDuplexChannel>())
{
return;
}
if (binding.Elements.Find <CompositeDuplexBindingElement>() == null)
{
return;
}
if (binding.CanBuildChannelFactory <IOutputChannel>() &&
binding.CanBuildChannelListener <IInputChannel>())
{
if (binding.CanBuildChannelListener <IReplyChannel>())
{
return;
}
if (binding.CanBuildChannelListener <IReplySessionChannel>())
{
return;
}
if (binding.CanBuildChannelListener <IInputSessionChannel>())
{
return;
}
if (binding.CanBuildChannelListener <IDuplexSessionChannel>())
{
return;
}
if (internalDuplexBindingElement == null)
{
internalDuplexBindingElement = new InternalDuplexBindingElement();
}
binding.Elements.Insert(0, internalDuplexBindingElement);
}
}
public void CanBuildSendChannelFactory()
{
Binding binding = new CustomBinding(new RedisMessageBindingElement(), new RedisSendTransportBinding());
Assert.True(binding.CanBuildChannelFactory<IDuplexChannel>());
}
public void CanBuildReceiveChannelFactory()
{
Binding binding = new CustomBinding(new RedisMessageBindingElement(), new RedisReceiveTransportBinding());
Assert.True(binding.CanBuildChannelFactory<IRequestChannel>());
}
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));
}
public bool CanBuildChannelFactory <TChannel>()
{
return(_binding.CanBuildChannelFactory <TChannel>(_bindingParameters));
}
public static ServiceChannelFactory BuildChannelFactory(ServiceEndpoint serviceEndpoint, bool useActiveAutoClose)
{
ChannelRequirements requirements;
BindingParameterCollection parameters;
if (serviceEndpoint == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceEndpoint");
}
serviceEndpoint.EnsureInvariants();
serviceEndpoint.ValidateForClient();
ChannelRequirements.ComputeContractRequirements(serviceEndpoint.Contract, out requirements);
System.ServiceModel.Dispatcher.ClientRuntime clientRuntime = DispatcherBuilder.BuildProxyBehavior(serviceEndpoint, out parameters);
Binding binding = serviceEndpoint.Binding;
System.Type[] requiredChannels = ChannelRequirements.ComputeRequiredChannels(ref requirements);
CustomBinding binding2 = new CustomBinding(binding);
BindingContext context = new BindingContext(binding2, parameters);
InternalDuplexBindingElement internalDuplexBindingElement = null;
InternalDuplexBindingElement.AddDuplexFactorySupport(context, ref internalDuplexBindingElement);
binding2 = new CustomBinding(context.RemainingBindingElements);
binding2.CopyTimeouts(serviceEndpoint.Binding);
foreach (System.Type type in requiredChannels)
{
if ((type == typeof(IOutputChannel)) && binding2.CanBuildChannelFactory <IOutputChannel>(parameters))
{
return(new ServiceChannelFactoryOverOutput(binding2.BuildChannelFactory <IOutputChannel>(parameters), clientRuntime, binding));
}
if ((type == typeof(IRequestChannel)) && binding2.CanBuildChannelFactory <IRequestChannel>(parameters))
{
return(new ServiceChannelFactoryOverRequest(binding2.BuildChannelFactory <IRequestChannel>(parameters), clientRuntime, binding));
}
if ((type == typeof(IDuplexChannel)) && binding2.CanBuildChannelFactory <IDuplexChannel>(parameters))
{
if (requirements.usesReply && binding.CreateBindingElements().Find <TransportBindingElement>().ManualAddressing)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("CantCreateChannelWithManualAddressing")));
}
return(new ServiceChannelFactoryOverDuplex(binding2.BuildChannelFactory <IDuplexChannel>(parameters), clientRuntime, binding));
}
if ((type == typeof(IOutputSessionChannel)) && binding2.CanBuildChannelFactory <IOutputSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverOutputSession(binding2.BuildChannelFactory <IOutputSessionChannel>(parameters), clientRuntime, binding, false));
}
if ((type == typeof(IRequestSessionChannel)) && binding2.CanBuildChannelFactory <IRequestSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverRequestSession(binding2.BuildChannelFactory <IRequestSessionChannel>(parameters), clientRuntime, binding, false));
}
if ((type == typeof(IDuplexSessionChannel)) && binding2.CanBuildChannelFactory <IDuplexSessionChannel>(parameters))
{
if (requirements.usesReply && binding.CreateBindingElements().Find <TransportBindingElement>().ManualAddressing)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("CantCreateChannelWithManualAddressing")));
}
return(new ServiceChannelFactoryOverDuplexSession(binding2.BuildChannelFactory <IDuplexSessionChannel>(parameters), clientRuntime, binding, useActiveAutoClose));
}
}
foreach (System.Type type2 in requiredChannels)
{
if ((type2 == typeof(IOutputChannel)) && binding2.CanBuildChannelFactory <IOutputSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverOutputSession(binding2.BuildChannelFactory <IOutputSessionChannel>(parameters), clientRuntime, binding, true));
}
if ((type2 == typeof(IRequestChannel)) && binding2.CanBuildChannelFactory <IRequestSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverRequestSession(binding2.BuildChannelFactory <IRequestSessionChannel>(parameters), clientRuntime, binding, true));
}
if (((type2 == typeof(IRequestSessionChannel)) && binding2.CanBuildChannelFactory <IRequestChannel>(parameters)) && (binding2.GetProperty <IContextSessionProvider>(parameters) != null))
{
return(new ServiceChannelFactoryOverRequest(binding2.BuildChannelFactory <IRequestChannel>(parameters), clientRuntime, binding));
}
}
Dictionary <System.Type, byte> dictionary = new Dictionary <System.Type, byte>();
if (binding2.CanBuildChannelFactory <IOutputChannel>(parameters))
{
dictionary.Add(typeof(IOutputChannel), 0);
}
if (binding2.CanBuildChannelFactory <IRequestChannel>(parameters))
{
dictionary.Add(typeof(IRequestChannel), 0);
}
if (binding2.CanBuildChannelFactory <IDuplexChannel>(parameters))
{
dictionary.Add(typeof(IDuplexChannel), 0);
}
if (binding2.CanBuildChannelFactory <IOutputSessionChannel>(parameters))
{
dictionary.Add(typeof(IOutputSessionChannel), 0);
}
if (binding2.CanBuildChannelFactory <IRequestSessionChannel>(parameters))
{
dictionary.Add(typeof(IRequestSessionChannel), 0);
}
if (binding2.CanBuildChannelFactory <IDuplexSessionChannel>(parameters))
{
dictionary.Add(typeof(IDuplexSessionChannel), 0);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ChannelRequirements.CantCreateChannelException(dictionary.Keys, requiredChannels, binding.Name));
}
