/// <summary>
///
/// </summary>
/// <param name="ip_address_or_host_name"></param>
/// <param name="binding_name">wcf 바인딩 명칭 (ex)net.tcp</param>
/// <param name="service_port">wcf접속시 연결 할 port번호</param>
public void Start(string ip_address_or_host_name, string binding_name, int service_port)
{
lock (SyncRoot)
{
Binding _binding;
var _address = String.Format("://{0}:{1}/{2}", ip_address_or_host_name, service_port, ServiceName);
if (binding_name.ToLower() == "WSHttpBinding".ToLower())
{
_address = "http" + _address;
WSHttpBinding _binding2 = new WSHttpBinding();
{
_binding2.TransactionFlow = false;
_binding2.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
_binding2.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None;
_binding2.Security.Mode = SecurityMode.None;
_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.ReaderQuotas = ReaderQuotas;
}
_binding = _binding2;
}
else if (binding_name.ToLower() == "WSDualHttpBinding".ToLower())
{
_address = "http" + _address;
WSDualHttpBinding _binding2 = new WSDualHttpBinding();
{
_binding2.TransactionFlow = false;
_binding2.Security.Message.ClientCredentialType = MessageCredentialType.None;
_binding2.Security.Mode = WSDualHttpSecurityMode.None;
_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.ReaderQuotas = ReaderQuotas;
}
_binding = _binding2;
}
else if (binding_name.ToLower() == "NetMsmqBinding".ToLower())
{
_address = String.Format("net.msmq://{0}/private/{1}", ip_address_or_host_name, ServiceName);
NetMsmqBinding _binding2 = new NetMsmqBinding();
{
_binding2.Security.Transport.MsmqAuthenticationMode = MsmqAuthenticationMode.None;
_binding2.Security.Transport.MsmqProtectionLevel = System.Net.Security.ProtectionLevel.None;
_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.SendTimeout = SendTimeout;
_binding2.ReceiveTimeout = ReceiveTimeout;
_binding2.ReaderQuotas = ReaderQuotas;
}
_binding = _binding2;
}
else if (binding_name.ToLower() == "NetNamedPipeBinding".ToLower())
{
_address = "net.pipe" + _address;
NetNamedPipeBinding _binding2 = new NetNamedPipeBinding();
{
_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.SendTimeout = SendTimeout;
_binding2.ReceiveTimeout = ReceiveTimeout;
_binding2.ReaderQuotas = ReaderQuotas;
}
_binding = _binding2;
}
//else if (_binding_name.ToLower() == "NetPeerTcpBinding".ToLower())
//{
// _address = "net.peer" + _address;
// NetPeerTcpBinding _binding2 = new NetPeerTcpBinding();
// {
// _binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
// _binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
// _binding2.SendTimeout = SendTimeout;
// _binding2.ReceiveTimeout = ReceiveTimeout;
// _binding2.ReaderQuotas = ReaderQuotas;
// }
// _binding = _binding2;
//}
else if (binding_name.ToLower() == "net.tcp".ToLower())
{
if (IsPortSharing == true)
{
service_port = SharingPort;
}
_address = String.Format("net.tcp://{0}:{1}/{2}", ip_address_or_host_name, service_port, ServiceName);
NetTcpBinding _binding2 = new NetTcpBinding();
{
_binding2.Security.Mode = SecurityMode.None;
_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.SendTimeout = SendTimeout;
_binding2.ReceiveTimeout = ReceiveTimeout;
_binding2.ReaderQuotas = ReaderQuotas;
_binding2.PortSharingEnabled = IsPortSharing;
}
_binding = _binding2;
}
else if (binding_name.ToLower() == "BasicHttpBinding".ToLower())
{
_address = "http" + _address;
BasicHttpBinding _binding2 = new BasicHttpBinding();
{
_binding2.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
_binding2.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None;
_binding2.Security.Mode = BasicHttpSecurityMode.None;
_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.ReaderQuotas = ReaderQuotas;
}
_binding = _binding2;
}
else if (binding_name.ToLower() == "WebHttpBinding".ToLower())
{
_address = "http" + _address;
WebHttpBinding _binding2 = new WebHttpBinding();
{
_binding2.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
_binding2.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None;
_binding2.Security.Mode = WebHttpSecurityMode.None;
_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.ReaderQuotas = ReaderQuotas;
}
_binding = _binding2;
}
else
{
_address = "http" + _address;
// Create a custom binding that contains two binding elements.
ReliableSessionBindingElement _reliableSession = new ReliableSessionBindingElement
{
InactivityTimeout = TimeSpan.FromDays(7),
Ordered = true
};
HttpTransportBindingElement _httpTransport = new HttpTransportBindingElement
{
AuthenticationScheme = System.Net.AuthenticationSchemes.Anonymous,
HostNameComparisonMode = HostNameComparisonMode.StrongWildcard
};
CustomBinding _binding2 = new CustomBinding(_reliableSession, _httpTransport);
{
//_binding2.MaxReceivedMessageSize *= MaxReceivedMessageSize;
//_binding2.MaxBufferPoolSize *= MaxBufferPoolSize;
_binding2.SendTimeout = SendTimeout;
_binding2.ReceiveTimeout = ReceiveTimeout;
//_binding2.ReaderQuotas = ReaderQuotas;
}
_binding = _binding2;
}
this.WcfAddress += _address + " ";
ServerHost.AddServiceEndpoint(InterfaceType, _binding, _address);
}
}
public ServiceResponseBase(NetMsmqBinding binding) : base(ResponseContext.Current,
binding,
new EndpointAddress(ResponseContext.Current.ResponseAddress))
{
Endpoint.VerifyQueue();
}
/// <summary>
/// Configures the specified binding.
/// </summary>
/// <param name="binding">The binding.</param>
/// <returns>Binding.</returns>
public override Binding Configure(
NetMsmqBinding binding)
{
IncompatibleBinding(binding);
return(binding);
}
internal static void ConfigureNone(IEnumerable <ServiceEndpoint> endpoints)
{
foreach (ServiceEndpoint endpoint in endpoints)
{
Binding binding = endpoint.Binding;
if (binding is BasicHttpBinding)
{
BasicHttpBinding basicBinding = (BasicHttpBinding)binding;
basicBinding.Security.Mode = BasicHttpSecurityMode.None;
continue;
}
if (binding is NetTcpBinding)
{
NetTcpBinding tcpBinding = (NetTcpBinding)binding;
tcpBinding.Security.Mode = SecurityMode.None;
continue;
}
if (binding is NetPeerTcpBinding)
{
NetPeerTcpBinding peerBinding = (NetPeerTcpBinding)binding;
peerBinding.Security.Mode = SecurityMode.None;
continue;
}
if (binding is NetNamedPipeBinding)
{
NetNamedPipeBinding pipeBinding = (NetNamedPipeBinding)binding;
pipeBinding.Security.Mode = NetNamedPipeSecurityMode.None;
continue;
}
if (binding is WSHttpBinding)
{
WSHttpBinding wsBinding = (WSHttpBinding)binding;
wsBinding.Security.Mode = SecurityMode.None;
continue;
}
if (binding is WSDualHttpBinding)
{
WSDualHttpBinding wsDualBinding = (WSDualHttpBinding)binding;
wsDualBinding.Security.Mode = WSDualHttpSecurityMode.None;
continue;
}
if (binding is NetMsmqBinding)
{
NetMsmqBinding msmqBinding = (NetMsmqBinding)binding;
msmqBinding.Security.Mode = NetMsmqSecurityMode.None;
continue;
}
if (endpoint.Contract.ContractType == typeof(IMetadataExchange))
{
Trace.WriteLine("No declarative security for MEX endpoint");
continue;
}
if (endpoint is DiscoveryEndpoint)
{
Trace.WriteLine("No declarative security for discovery endpoint");
continue;
}
throw new InvalidOperationException(binding.GetType() + " is unsupported with ServiceSecurity.None");
}
}
/// <summary>
/// Creates the appropriate binding type for the given element
/// </summary>
/// <param name="endPoint">Enpoint to create binding object for</param>
/// <returns>Binding represented in the config file</returns>
private static Binding GetBinding(ChannelEndpointElement endPoint)
{
Binding binding = null;
try
{
switch (endPoint.Binding)
{
case "basicHttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new BasicHttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new BasicHttpBinding();
}
break;
case "basicHttpContextBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new BasicHttpContextBinding(endPoint.BindingConfiguration);
}
else
{
binding = new BasicHttpContextBinding();
}
break;
case "customBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new CustomBinding(endPoint.BindingConfiguration);
}
else
{
binding = new CustomBinding();
}
break;
case "netNamedPipeBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new NetNamedPipeBinding(endPoint.BindingConfiguration);
}
else
{
binding = new NetNamedPipeBinding();
}
break;
case "netPeerTcpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new NetPeerTcpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new NetPeerTcpBinding();
}
break;
case "netTcpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new NetTcpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new NetTcpBinding();
}
break;
case "netTcpContextBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new NetTcpContextBinding(endPoint.BindingConfiguration);
}
else
{
binding = new NetTcpContextBinding();
}
break;
case "webHttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new WebHttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new WebHttpBinding();
}
break;
case "ws2007HttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new WS2007HttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new WS2007HttpBinding();
}
break;
case "wsHttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new WSHttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new WSHttpBinding();
}
break;
case "wsHttpContextBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new WSHttpContextBinding(endPoint.BindingConfiguration);
}
else
{
binding = new WSHttpContextBinding();
}
break;
case "wsDualHttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new WSDualHttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new WSDualHttpBinding();
}
break;
case "wsFederationHttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new WSFederationHttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new WSFederationHttpBinding();
}
break;
case "ws2007FederationHttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new WS2007FederationHttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new WS2007FederationHttpBinding();
}
break;
case "msmqIntegrationBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new MsmqIntegrationBinding(endPoint.BindingConfiguration);
}
else
{
binding = new MsmqIntegrationBinding();
}
break;
case "netMsmqBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new NetMsmqBinding(endPoint.BindingConfiguration);
}
else
{
binding = new NetMsmqBinding();
}
break;
case "netHttpBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new NetHttpBinding(endPoint.BindingConfiguration);
}
else
{
binding = new NetHttpBinding();
}
break;
case "netHttpsBinding":
if (!string.IsNullOrEmpty(endPoint.BindingConfiguration))
{
binding = new NetHttpsBinding(endPoint.BindingConfiguration);
}
else
{
binding = new NetHttpBinding();
}
break;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Namespace + "." + System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name);
throw ex;
}
return(binding);
}
public ClientResponseBase(string responseAddress, NetMsmqBinding binding, EndpointAddress remoteAddress) : base(binding, remoteAddress)
{
ResponseAddress = responseAddress;
Endpoint.VerifyQueue();
}
void ConfigureSecurityMode(Binding binding)
{
SecurityModeEx securityMode = SecurityModeEx.None;
bool enabled = false;
if (binding is NetTcpBinding)
{
NetTcpBinding tcpBinding = binding as NetTcpBinding;
switch (tcpBinding.Security.Mode)
{
case SecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case SecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case SecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
case SecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Mixed;
break;
}
}
enabled = true;
}
if (binding is NetNamedPipeBinding)
{
NetNamedPipeBinding pipeBinding = binding as NetNamedPipeBinding;
switch (pipeBinding.Security.Mode)
{
case NetNamedPipeSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case NetNamedPipeSecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
}
enabled = true;
}
if (binding is NetMsmqBinding)
{
NetMsmqBinding msmqBinding = binding as NetMsmqBinding;
switch (msmqBinding.Security.Mode)
{
case NetMsmqSecurityMode.Both:
{
securityMode = SecurityModeEx.Both;
break;
}
case NetMsmqSecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case NetMsmqSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case NetMsmqSecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
}
enabled = true;
}
if (binding is BasicHttpBinding)
{
BasicHttpBinding basicBinding = binding as BasicHttpBinding;
switch (basicBinding.Security.Mode)
{
case BasicHttpSecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case BasicHttpSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case BasicHttpSecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
case BasicHttpSecurityMode.TransportCredentialOnly:
{
securityMode = SecurityModeEx.Transport;
break;
}
case BasicHttpSecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Mixed;
break;
}
}
enabled = true;
}
if (binding is WSHttpBinding)
{
WSHttpBinding wsBinding = binding as WSHttpBinding;
switch (wsBinding.Security.Mode)
{
case SecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case SecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case SecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
case SecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Mixed;
break;
}
}
enabled = true;
}
if (binding is WSDualHttpBinding)
{
WSDualHttpBinding wsDualBinding = binding as WSDualHttpBinding;
switch (wsDualBinding.Security.Mode)
{
case WSDualHttpSecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case WSDualHttpSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
}
enabled = true;
}
if (binding is NetPeerTcpBinding)
{
NetPeerTcpBinding peerBinding = binding as NetPeerTcpBinding;
switch (peerBinding.Security.Mode)
{
case SecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case SecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case SecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
case SecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Transport;
break;
}
}
enabled = true;
}
if (binding is WSFederationHttpBinding)
{
WSFederationHttpBinding federatedBinding = binding as WSFederationHttpBinding;
switch (federatedBinding.Security.Mode)
{
case WSFederationHttpSecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case WSFederationHttpSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case WSFederationHttpSecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Mixed;
break;
}
}
enabled = true;
}
if (binding is NetTcpRelayBinding)
{
NetTcpRelayBinding tcpRelayBinding = binding as NetTcpRelayBinding;
switch (tcpRelayBinding.Security.Mode)
{
case EndToEndSecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case EndToEndSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case EndToEndSecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
case EndToEndSecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Mixed;
break;
}
}
enabled = true;
}
if (binding is BasicHttpRelayBinding)
{
BasicHttpRelayBinding basicRelayBinding = binding as BasicHttpRelayBinding;
switch (basicRelayBinding.Security.Mode)
{
case EndToEndBasicHttpSecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case EndToEndBasicHttpSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case EndToEndBasicHttpSecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
case EndToEndBasicHttpSecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Mixed;
break;
}
}
enabled = true;
}
if (binding is NetOnewayRelayBinding)
{
NetOnewayRelayBinding onewayRelayBinding = binding as NetOnewayRelayBinding;
switch (onewayRelayBinding.Security.Mode)
{
case EndToEndSecurityMode.Message:
{
securityMode = SecurityModeEx.Message;
break;
}
case EndToEndSecurityMode.None:
{
securityMode = SecurityModeEx.None;
break;
}
case EndToEndSecurityMode.Transport:
{
securityMode = SecurityModeEx.Transport;
break;
}
case EndToEndSecurityMode.TransportWithMessageCredential:
{
securityMode = SecurityModeEx.Mixed;
break;
}
}
enabled = true;
}
if (binding is CustomBinding)
{
enabled = false;
}
m_NoneRadioButton.Checked = securityMode == SecurityModeEx.None;
m_TransportRadioButton.Checked = securityMode == SecurityModeEx.Transport;
m_MessageRadioButton.Checked = securityMode == SecurityModeEx.Message;
m_MixedRadioButton.Checked = securityMode == SecurityModeEx.Mixed;
m_BothRadioButton.Checked = securityMode == SecurityModeEx.Both;
m_NoneRadioButton.Enabled = enabled;
m_TransportRadioButton.Enabled = enabled;
m_MessageRadioButton.Enabled = enabled;
m_MixedRadioButton.Enabled = enabled;
m_BothRadioButton.Enabled = enabled;
}
static bool UsesCertificateClientCredentials(ServiceEndpoint endpoint)
{
bool usesCertificates = false;
if (endpoint.Binding is NetTcpBinding)
{
NetTcpBinding binding = endpoint.Binding as NetTcpBinding;
if (binding.Security.Mode == SecurityMode.Transport)
{
usesCertificates = binding.Security.Transport.ClientCredentialType == TcpClientCredentialType.Certificate;
}
if (binding.Security.Mode == SecurityMode.Message || binding.Security.Mode == SecurityMode.TransportWithMessageCredential)
{
usesCertificates = binding.Security.Message.ClientCredentialType == MessageCredentialType.Certificate;
}
}
if (endpoint.Binding is NetMsmqBinding)
{
NetMsmqBinding binding = endpoint.Binding as NetMsmqBinding;
if (binding.Security.Mode == NetMsmqSecurityMode.Transport || binding.Security.Mode == NetMsmqSecurityMode.Both)
{
usesCertificates = binding.Security.Transport.MsmqAuthenticationMode == MsmqAuthenticationMode.Certificate;
}
if (binding.Security.Mode == NetMsmqSecurityMode.Message || binding.Security.Mode == NetMsmqSecurityMode.Both)
{
usesCertificates = binding.Security.Message.ClientCredentialType == MessageCredentialType.Certificate;
}
}
if (endpoint.Binding is WSHttpBinding)
{
WSHttpBinding binding = endpoint.Binding as WSHttpBinding;
if (binding.Security.Mode == SecurityMode.Transport)
{
usesCertificates = binding.Security.Transport.ClientCredentialType == HttpClientCredentialType.Certificate;
}
if (binding.Security.Mode == SecurityMode.Message || binding.Security.Mode == SecurityMode.TransportWithMessageCredential)
{
usesCertificates = binding.Security.Message.ClientCredentialType == MessageCredentialType.Certificate;
}
}
if (endpoint.Binding is WSDualHttpBinding)
{
WSDualHttpBinding binding = endpoint.Binding as WSDualHttpBinding;
if (binding.Security.Mode == WSDualHttpSecurityMode.Message)
{
usesCertificates = binding.Security.Message.ClientCredentialType == MessageCredentialType.None;
}
}
if (endpoint.Binding is BasicHttpBinding)
{
BasicHttpBinding binding = endpoint.Binding as BasicHttpBinding;
switch (binding.Security.Mode)
{
case BasicHttpSecurityMode.Message:
{
usesCertificates = binding.Security.Message.ClientCredentialType == BasicHttpMessageCredentialType.Certificate;
break;
}
case BasicHttpSecurityMode.TransportCredentialOnly:
case BasicHttpSecurityMode.TransportWithMessageCredential:
case BasicHttpSecurityMode.Transport:
{
usesCertificates = binding.Security.Transport.ClientCredentialType == HttpClientCredentialType.Certificate;
break;
}
}
}
if (endpoint.Binding is WebHttpBinding)
{
WebHttpBinding binding = endpoint.Binding as WebHttpBinding;
if (binding.Security.Mode == WebHttpSecurityMode.Transport)
{
usesCertificates = binding.Security.Transport.ClientCredentialType == HttpClientCredentialType.Certificate;
}
}
return(usesCertificates);
}
private Binding SetNetMsmqBinding(NetMsmqBinding binding)
{
binding.MaxReceivedMessageSize = 2147483647;
return(binding);
}
void ConfigureCredentialsType(Binding binding)
{
CredentialTypeEx credentialType = CredentialTypeEx.None;
bool enabled = false;
if (binding is NetTcpBinding)
{
NetTcpBinding tcpBinding = binding as NetTcpBinding;
switch (tcpBinding.Security.Mode)
{
case SecurityMode.Message:
{
credentialType = ConvertCredentials(tcpBinding.Security.Message.ClientCredentialType);
break;
}
case SecurityMode.None:
{
credentialType = CredentialTypeEx.None;
break;
}
case SecurityMode.Transport:
{
credentialType = ConvertCredentials(tcpBinding.Security.Transport.ClientCredentialType);
break;
}
}
enabled = true;
}
if (binding is NetNamedPipeBinding)
{
NetNamedPipeBinding pipeBinding = binding as NetNamedPipeBinding;
switch (pipeBinding.Security.Mode)
{
case NetNamedPipeSecurityMode.None:
{
credentialType = CredentialTypeEx.None;
break;
}
case NetNamedPipeSecurityMode.Transport:
{
credentialType = CredentialTypeEx.Windows;
break;
}
}
enabled = true;
}
if (binding is NetMsmqBinding)
{
NetMsmqBinding msmqBinding = binding as NetMsmqBinding;
switch (msmqBinding.Security.Mode)
{
case NetMsmqSecurityMode.Both:
case NetMsmqSecurityMode.Message:
{
credentialType = ConvertCredentials(msmqBinding.Security.Message.ClientCredentialType);
break;
}
case NetMsmqSecurityMode.None:
{
credentialType = CredentialTypeEx.None;
break;
}
case NetMsmqSecurityMode.Transport:
{
credentialType = ConvertCredentials(msmqBinding.Security.Transport.MsmqAuthenticationMode);
break;
}
}
enabled = true;
}
if (binding is BasicHttpBinding)
{
BasicHttpBinding basicBinding = binding as BasicHttpBinding;
switch (basicBinding.Security.Mode)
{
case BasicHttpSecurityMode.Message:
case BasicHttpSecurityMode.TransportWithMessageCredential:
{
credentialType = ConvertCredentials(basicBinding.Security.Message.ClientCredentialType);
break;
}
case BasicHttpSecurityMode.None:
{
credentialType = CredentialTypeEx.None;
break;
}
case BasicHttpSecurityMode.Transport:
case BasicHttpSecurityMode.TransportCredentialOnly:
{
credentialType = ConvertCredentials(basicBinding.Security.Transport.ClientCredentialType);
break;
}
}
enabled = true;
}
if (binding is WSHttpBinding)
{
WSHttpBinding wsBinding = binding as WSHttpBinding;
switch (wsBinding.Security.Mode)
{
case SecurityMode.TransportWithMessageCredential:
case SecurityMode.Message:
{
credentialType = ConvertCredentials(wsBinding.Security.Message.ClientCredentialType);
break;
}
case SecurityMode.None:
{
credentialType = CredentialTypeEx.None;
break;
}
case SecurityMode.Transport:
{
credentialType = ConvertCredentials(wsBinding.Security.Transport.ClientCredentialType);
break;
}
}
enabled = true;
}
if (binding is WSDualHttpBinding)
{
WSDualHttpBinding wsDualBinding = binding as WSDualHttpBinding;
switch (wsDualBinding.Security.Mode)
{
case WSDualHttpSecurityMode.Message:
{
credentialType = ConvertCredentials(wsDualBinding.Security.Message.ClientCredentialType);
break;
}
case WSDualHttpSecurityMode.None:
{
credentialType = CredentialTypeEx.None;
break;
}
}
enabled = true;
}
if (binding is NetPeerTcpBinding)
{
NetPeerTcpBinding peerBinding = binding as NetPeerTcpBinding;
switch (peerBinding.Security.Mode)
{
case SecurityMode.None:
{
credentialType = CredentialTypeEx.None;
break;
}
case SecurityMode.Transport:
{
credentialType = ConvertCredentials(peerBinding.Security.Transport.CredentialType);
break;
}
}
enabled = true;
}
if (binding is WSFederationHttpBinding)
{
credentialType = CredentialTypeEx.Token;
enabled = true;
}
if (binding is NetTcpRelayBinding)
{
credentialType = CredentialTypeEx.Token;
enabled = true;
}
if (binding is BasicHttpRelayBinding)
{
credentialType = CredentialTypeEx.Token;
enabled = true;
}
m_NoCredentialsRadioButton.Checked = credentialType == CredentialTypeEx.None;
m_WindowsCredentialsRadioButton.Checked = credentialType == CredentialTypeEx.Windows;
m_UsernameCredentialsRadioButton.Checked = credentialType == CredentialTypeEx.Username;
m_CertificateCredentialsRadioButton.Checked = credentialType == CredentialTypeEx.Certificate;
m_TokenRadioButton.Checked = credentialType == CredentialTypeEx.Token;
m_NoCredentialsRadioButton.Enabled = enabled;
m_WindowsCredentialsRadioButton.Enabled = enabled;
m_UsernameCredentialsRadioButton.Enabled = enabled;
m_CertificateCredentialsRadioButton.Enabled = enabled;
m_TokenRadioButton.Enabled = enabled;
}
public WcfMsmqChannelManager(string address, string bindingConfiguration)
{
var binding = new NetMsmqBinding(bindingConfiguration);
_channelFactory = new ChannelFactory <TChannel>(binding, new EndpointAddress(address));
}
/// <summary>
/// Creates a <see cref="Binding"/> based on the specified <paramref name="address"/>.
/// </summary>
/// <param name="address">The URI that is used to determine the type of <see cref="Binding"/> to be created.</param>
/// <param name="enableSecurity">A boolean value that indicated whether security is to be enabled on the <see cref="Binding"/>.</param>
/// <returns>An <see cref="Binding"/> object if a valid <paramref name="address"/> is specified; otherwise null.</returns>
/// <remarks>
/// This list shows all valid address schemes that can be specified in the <paramref name="address"/>:
/// <list type="table">
/// <listheader>
/// <term>Address Scheme</term>
/// <description>Usage</description>
/// </listheader>
/// <item>
/// <term><b>http://</b> or <b>http.soap11://</b></term>
/// <description>An <paramref name="address"/> of <b>http.soap11://localhost:2929</b> will create an <see cref="BasicHttpBinding"/> and update the <paramref name="address"/> to <b>http://localhost:2929</b>.</description>
/// </item>
/// <item>
/// <term><b>http.soap12://</b></term>
/// <description>An <paramref name="address"/> of <b>http.soap12://localhost:2929</b> will create an <see cref="WSHttpBinding"/> and update the <paramref name="address"/> to <b>http://localhost:2929</b>.</description>
/// </item>
/// <item>
/// <term><b>http.duplex://</b></term>
/// <description>An <paramref name="address"/> of <b>http.duplex://localhost:2929</b> will create an <see cref="WSDualHttpBinding"/> and update the <paramref name="address"/> to <b>http://localhost:2929</b>.</description>
/// </item>
/// <item>
/// <term><b>http.rest://</b></term>
/// <description>An <paramref name="address"/> of <b>http.rest://localhost:2929</b> will create an <see cref="WebHttpBinding"/> and update the <paramref name="address"/> to <b>http://localhost:2929</b>.</description>
/// </item>
/// <item>
/// <term><b>net.tcp://</b></term>
/// <description>An <paramref name="address"/> of <b>net.tcp://localhost:2929</b> will create an <see cref="NetTcpBinding"/> and leave the <paramref name="address"/> unchanged.</description>
/// </item>
/// <item>
/// <term><b>net.p2p://</b></term>
/// <description>An <paramref name="address"/> of <b>net.p2p://localhost:2929</b> will create an <see cref="NetPeerTcpBinding"/> and leave the <paramref name="address"/> unchanged.</description>
/// </item>
/// <item>
/// <term><b>net.pipe://</b></term>
/// <description>An <paramref name="address"/> of <b>net.pipe://localhost:2929</b> will create an <see cref="NetNamedPipeBinding"/> and leave the <paramref name="address"/> unchanged.</description>
/// </item>
/// <item>
/// <term><b>net.msmq://</b></term>
/// <description>An <paramref name="address"/> of <b>net.msmq://localhost:2929</b> will create an <see cref="NetMsmqBinding"/> and leave the <paramref name="address"/> unchanged.</description>
/// </item>
/// </list>
/// <para>
/// The <paramref name="enableSecurity"/> parameter value is ignored Mono deployments since security bindings are not implemented.
/// </para>
/// </remarks>
public static Binding CreateServiceBinding(ref string address, bool enableSecurity)
{
address = address.Trim();
if (string.IsNullOrEmpty(address))
{
return(null);
}
int index = address.IndexOf("://");
string scheme = address.Substring(0, index >= 0 ? index : address.Length);
switch (scheme.ToLower())
{
case "http":
case "http.soap11":
// Format address.
address = address.Replace("http.soap11", "http");
// Create binding.
BasicHttpBinding soap11Binding = new BasicHttpBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
soap11Binding.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
soap11Binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;
}
else
{
// Disable security.
soap11Binding.Security.Mode = BasicHttpSecurityMode.None;
soap11Binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
}
#endif
return(soap11Binding);
case "http.soap12":
// Format address.
address = address.Replace("http.soap12", "http");
// Create binding.
WSHttpBinding soap12Binding = new WSHttpBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
soap12Binding.Security.Mode = SecurityMode.Transport;
soap12Binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;
}
else
{
// Disable security.
soap12Binding.Security.Mode = SecurityMode.None;
soap12Binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
}
#endif
return(soap12Binding);
case "http.duplex":
// Format address.
address = address.Replace("http.duplex", "http");
// Create binding.
WSDualHttpBinding duplexBinding = new WSDualHttpBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
duplexBinding.Security.Mode = WSDualHttpSecurityMode.Message;
}
else
{
// Disable security.
duplexBinding.Security.Mode = WSDualHttpSecurityMode.None;
}
#endif
return(duplexBinding);
case "http.rest":
// Format address.
address = address.Replace("http.rest", "http");
// Create binding.
WebHttpBinding restBinding = new WebHttpBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
restBinding.Security.Mode = WebHttpSecurityMode.TransportCredentialOnly;
restBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;
}
else
{
// Disable security.
restBinding.Security.Mode = WebHttpSecurityMode.None;
restBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
}
#endif
return(restBinding);
case "net.tcp":
// Create binding.
NetTcpBinding tcpBinding = new NetTcpBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
tcpBinding.Security.Mode = SecurityMode.Transport;
tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows;
}
else
{
// Disable sercurity.
tcpBinding.Security.Mode = SecurityMode.None;
tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None;
}
#endif
return(tcpBinding);
case "net.p2p":
// Create binding.
#pragma warning disable 612, 618
NetPeerTcpBinding p2pBinding = new NetPeerTcpBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
p2pBinding.Security.Mode = SecurityMode.Transport;
}
else
{
// Disable security.
p2pBinding.Security.Mode = SecurityMode.None;
}
#endif
return(p2pBinding);
case "net.pipe":
// Create binding.
NetNamedPipeBinding pipeBinding = new NetNamedPipeBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
pipeBinding.Security.Mode = NetNamedPipeSecurityMode.Transport;
}
else
{
// Disable security.
pipeBinding.Security.Mode = NetNamedPipeSecurityMode.None;
}
#endif
return(pipeBinding);
case "net.msmq":
// Create binding.
NetMsmqBinding msmqBinding = new NetMsmqBinding();
#if !MONO
if (enableSecurity)
{
// Enable security.
msmqBinding.Security.Mode = NetMsmqSecurityMode.Transport;
}
else
{
// Disable security.
msmqBinding.Security.Mode = NetMsmqSecurityMode.None;
}
#endif
return(msmqBinding);
default:
return(null);
}
}
public static List <NetMsmqBinding> GetNetMsmqBindings(string exeConfigPath)
{
if (string.IsNullOrWhiteSpace(exeConfigPath))
{
return(null);
}
var svcSection = Read.Config.ExeConfig.GetServiceModelSection(exeConfigPath);
var configs = new List <NetMsmqBinding>();
foreach (
var section in
svcSection.Bindings.NetMsmqBinding.ConfiguredBindings
.Cast <NetMsmqBindingElement>())
{
var df = new NetMsmqBinding();
var binding = new NetMsmqBinding
{
Name = section.Name,
MaxBufferPoolSize = section.MaxBufferPoolSize > 0 ? section.MaxBufferPoolSize : df.MaxBufferPoolSize,
MaxReceivedMessageSize = section.MaxReceivedMessageSize > 0 ? section.MaxReceivedMessageSize : df.MaxReceivedMessageSize,
CloseTimeout = section.CloseTimeout != TimeSpan.Zero ? section.CloseTimeout : df.CloseTimeout,
OpenTimeout = section.OpenTimeout != TimeSpan.Zero ? section.OpenTimeout : df.OpenTimeout,
SendTimeout = section.SendTimeout != TimeSpan.Zero ? section.SendTimeout : df.SendTimeout,
ReceiveTimeout =
section.ReceiveTimeout != TimeSpan.Zero ? section.ReceiveTimeout : df.ReceiveTimeout,
MaxRetryCycles = section.MaxRetryCycles > 0 ? section.MaxRetryCycles : df.MaxRetryCycles,
ReceiveRetryCount = section.ReceiveRetryCount > 0 ? section.ReceiveRetryCount : df.ReceiveRetryCount,
RetryCycleDelay = section.RetryCycleDelay != TimeSpan.Zero ? section.RetryCycleDelay : df.RetryCycleDelay,
TimeToLive = section.TimeToLive != TimeSpan.Zero ? section.TimeToLive : df.TimeToLive,
DeadLetterQueue = section.DeadLetterQueue,
Durable = section.Durable,
ExactlyOnce = section.ExactlyOnce,
ReceiveErrorHandling = section.ReceiveErrorHandling,
UseSourceJournal = section.UseSourceJournal,
UseMsmqTracing = section.UseMsmqTracing,
QueueTransferProtocol = section.QueueTransferProtocol,
UseActiveDirectory = section.UseActiveDirectory
};
var readerQuotasSection = section.ReaderQuotas;
var readerQuotas = new System.Xml.XmlDictionaryReaderQuotas();
if (readerQuotasSection != null && readerQuotasSection.MaxDepth > 0)
{
readerQuotas.MaxDepth = readerQuotasSection.MaxDepth;
readerQuotas.MaxStringContentLength = readerQuotasSection.MaxStringContentLength;
readerQuotas.MaxArrayLength = readerQuotasSection.MaxArrayLength;
readerQuotas.MaxBytesPerRead = readerQuotasSection.MaxBytesPerRead;
readerQuotas.MaxNameTableCharCount = readerQuotasSection.MaxNameTableCharCount;
}
else
{
readerQuotas = null;
}
var msmqSecurity = new NetMsmqSecurity {
Mode = section.Security.Mode
};
var securityTransportSection = section.Security.Transport;
var msmqSecurityTransport = new MsmqTransportSecurity
{
MsmqAuthenticationMode = securityTransportSection.MsmqAuthenticationMode,
MsmqEncryptionAlgorithm = securityTransportSection.MsmqEncryptionAlgorithm,
MsmqProtectionLevel = securityTransportSection.MsmqProtectionLevel,
MsmqSecureHashAlgorithm = securityTransportSection.MsmqSecureHashAlgorithm
};
var msmqSecurityMessage = new MessageSecurityOverMsmq
{
ClientCredentialType = section.Security.Message.ClientCredentialType
};
msmqSecurity.Message = msmqSecurityMessage;
msmqSecurity.Transport = msmqSecurityTransport;
binding.Security = msmqSecurity;
if (readerQuotas != null)
{
binding.ReaderQuotas = readerQuotas;
}
configs.Add(binding);
}
return(configs);
}
public CalculatorClient(string responseAddress, NetMsmqBinding binding, EndpointAddress remoteAddress) : base(responseAddress, binding, remoteAddress)
{
}
/// <summary>
/// Creates the specified binding.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="queuePath">The queue path.</param>
/// <returns></returns>
public static VisualRxWcfQueuedProxy Create(NetMsmqBinding binding, string queuePath)
{
var endpoint = new EndpointAddress(queuePath);
return(Create(binding, endpoint));
}
internal static void DemandTransactionPermissions(ServiceEndpoint endpoint, string operationName)
{
bool transactionFlow = false;
bool flowOptionAllowed = false;
if (endpoint.Binding is NetMsmqBinding)
{
NetMsmqBinding msmqBinding = endpoint.Binding as NetMsmqBinding;
if (msmqBinding.Durable)
{
transactionFlow = true;
if (Transaction.Current != null)
{
flowOptionAllowed = true;
}
}
}
if (endpoint.Binding is NetTcpBinding)
{
NetTcpBinding tcpBinding = endpoint.Binding as NetTcpBinding;
transactionFlow = tcpBinding.TransactionFlow;
}
if (endpoint.Binding is NetNamedPipeBinding)
{
NetNamedPipeBinding ipcBinding = endpoint.Binding as NetNamedPipeBinding;
transactionFlow = ipcBinding.TransactionFlow;
}
if (endpoint.Binding is WSHttpBinding)
{
WSHttpBinding wsBinding = endpoint.Binding as WSHttpBinding;
transactionFlow = wsBinding.TransactionFlow;
}
if (endpoint.Binding is WSDualHttpBinding)
{
WSDualHttpBinding wsDualBinding = endpoint.Binding as WSDualHttpBinding;
transactionFlow = wsDualBinding.TransactionFlow;
}
if (transactionFlow)
{
if (Transaction.Current != null)
{
//If operationName is null, then at least one operation needs to allow flow
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
string name = operationName ?? operation.Name;
if (name != operation.Name)
{
continue;
}
TransactionFlowAttribute attribute = operation.Behaviors.Find <TransactionFlowAttribute>();
if (attribute == null)
{
continue;
}
if (attribute.Transactions != TransactionFlowOption.NotAllowed)
{
flowOptionAllowed = true;
break;
}
}
if (flowOptionAllowed)
{
IPermission distributedTransactionPermission = new DistributedTransactionPermission(PermissionState.Unrestricted);
distributedTransactionPermission.Demand();
}
}
}
}
/// <summary>
/// Creates the specified binding.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="endpoint">The endpoint.</param>
/// <returns></returns>
public static VisualRxWcfQueuedProxy Create(NetMsmqBinding binding, EndpointAddress endpoint)
{
return(new VisualRxWcfQueuedProxy(binding, endpoint));
}
static bool IsAnonymous(ServiceEndpoint endpoint)
{
if (SecurityEnabled(endpoint) == false)
{
return(true);
}
bool anonymous = false;
if (endpoint.Binding is NetTcpBinding)
{
NetTcpBinding binding = endpoint.Binding as NetTcpBinding;
if (binding.Security.Mode == SecurityMode.Message)
{
anonymous = binding.Security.Message.ClientCredentialType == MessageCredentialType.None;
}
if (binding.Security.Mode == SecurityMode.Transport)
{
anonymous = binding.Security.Transport.ClientCredentialType == TcpClientCredentialType.None;
}
}
if (endpoint.Binding is NetMsmqBinding)
{
NetMsmqBinding binding = endpoint.Binding as NetMsmqBinding;
if (binding.Security.Mode == NetMsmqSecurityMode.Message)
{
anonymous = binding.Security.Message.ClientCredentialType == MessageCredentialType.None;
}
if (binding.Security.Mode == NetMsmqSecurityMode.Transport)
{
anonymous = binding.Security.Transport.MsmqAuthenticationMode == MsmqAuthenticationMode.None;
}
}
if (endpoint.Binding is BasicHttpBinding)
{
BasicHttpBinding binding = endpoint.Binding as BasicHttpBinding;
if (binding.Security.Mode == BasicHttpSecurityMode.Transport)
{
anonymous = binding.Security.Transport.ClientCredentialType == HttpClientCredentialType.None;
}
}
if (endpoint.Binding is WSHttpBinding)
{
WSHttpBinding binding = endpoint.Binding as WSHttpBinding;
if (binding.Security.Mode == SecurityMode.Message)
{
anonymous = binding.Security.Message.ClientCredentialType == MessageCredentialType.None;
}
if (binding.Security.Mode == SecurityMode.Transport)
{
anonymous = binding.Security.Transport.ClientCredentialType == HttpClientCredentialType.None;
}
}
if (endpoint.Binding is WSDualHttpBinding)
{
WSDualHttpBinding binding = endpoint.Binding as WSDualHttpBinding;
if (binding.Security.Mode == WSDualHttpSecurityMode.Message)
{
anonymous = binding.Security.Message.ClientCredentialType == MessageCredentialType.None;
}
}
if (endpoint.Binding is WebHttpBinding)
{
WebHttpBinding binding = endpoint.Binding as WebHttpBinding;
anonymous = binding.Security.Transport.ClientCredentialType == HttpClientCredentialType.None;
}
return(anonymous);
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualRxWcfQueuedProxy"/> class.
/// </summary>
/// <param name="binding">The binding.</param>
/// <param name="endpoint">The endpoint.</param>
private VisualRxWcfQueuedProxy(NetMsmqBinding binding, EndpointAddress endpoint)
{
_binding = binding;
_endpoint = endpoint;
_proxy = new Lazy <ProxyFactory>(() => new ProxyFactory(binding, endpoint));
}
// public NetMsmqBinding(NetMsmqSecurityMode)
public static void Snippet8()
{
// <Snippet8>
NetMsmqBinding binding = new NetMsmqBinding(NetMsmqSecurityMode.Message);
// </Snippet8>
}
/// <summary>
/// Method used to set the binding
/// </summary>
/// <param name="binding">The binding to set</param>
public static void SetBinding(NetMsmqBinding binding)
{
_defaultBinding = binding;
}
public ResponseClientBase(string responseAddress, NetMsmqBinding binding, EndpointAddress remoteAddress) : base(binding, remoteAddress)
{
ResponseAddress = responseAddress;
QueuedServiceHelper.VerifyQueue(Endpoint);
}
internal static Binding CreateBinding(string scheme, int limitMultiplier, TimeSpan msgLifetime)
{
// returns a wcf binding with send/recv limits to n times default size
const int poolMultiplier = 8;
switch (scheme)
{
case WcfConst.NetMsmq:
{
var msmqBinding = new NetMsmqBinding(NetMsmqSecurityMode.None)
{
ExactlyOnce = false,
Durable = false,
TimeToLive = msgLifetime,
MaxReceivedMessageSize = limitMultiplier * 64 * 1024,
ReaderQuotas =
{
MaxStringContentLength = limitMultiplier * 8 * 1024,
MaxArrayLength = limitMultiplier * 16384,
MaxBytesPerRead = limitMultiplier * 4096
},
MaxBufferPoolSize = poolMultiplier * limitMultiplier * 512 * 1024
};
return(msmqBinding);
}
case WcfConst.NetPipe:
{
var pipeBinding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
{
MaxReceivedMessageSize = limitMultiplier * 64 * 1024,
ReaderQuotas =
{
MaxStringContentLength = limitMultiplier * 8 * 1024,
MaxArrayLength = limitMultiplier * 16384,
MaxBytesPerRead = limitMultiplier * 4096
},
MaxBufferPoolSize = poolMultiplier * limitMultiplier * 512 * 1024
};
return(pipeBinding);
}
case WcfConst.NetTcp:
{
var tcpBinding = new NetTcpBinding(SecurityMode.None)
{
MaxReceivedMessageSize = limitMultiplier * 64 * 1024,
ReaderQuotas =
{
MaxStringContentLength = limitMultiplier * 8 * 1024,
MaxArrayLength = limitMultiplier * 16384,
MaxBytesPerRead = limitMultiplier * 4096
},
MaxBufferPoolSize = poolMultiplier * limitMultiplier * 512 * 1024
};
return(tcpBinding);
}
case WcfConst.Http:
{
var httpBinding = new BasicHttpBinding(BasicHttpSecurityMode.None)
{
MaxReceivedMessageSize = limitMultiplier * 64 * 1024,
ReaderQuotas =
{
MaxStringContentLength = limitMultiplier * 8 * 1024,
MaxArrayLength = limitMultiplier * 16384,
MaxBytesPerRead = limitMultiplier * 4096
},
MaxBufferPoolSize = poolMultiplier * limitMultiplier * 512 * 1024
};
return(httpBinding);
}
default:
throw new NotSupportedException($"scheme: '{scheme}'");
}
}
private void SetBinding(NetMsmqBinding netMsmqBinding)
{
throw new Exception("The method or operation is not implemented.");
}
/// <summary>
/// Configure an endpoint from a setting
/// </summary>
protected virtual IChannelWrapper <I> ConfigureEndpointFromSetting <I>(ClientEndpoint endpoint)
where I : class
{
IChannelWrapper <I> result = null;
if (!string.IsNullOrWhiteSpace(endpoint.Implementation))
{
Type t = Type.GetType(endpoint.Implementation);
if (t == null)
{
throw new InvalidOperationException(
string.Format(
"Unable to create service type, your configuration for endpoint.Implementation is probably wrong or you need to add a reference to an assembly. Configured as {0}.",
endpoint.Implementation));
}
if (endpoint.UseWcf)
{
result = CreateInProcWrapper <I>(t);
}
else
{
result = new MockChannelWrapper <I>()
{
Instance = Activator.CreateInstance(t) as I
};
}
}
else if (!string.IsNullOrWhiteSpace(endpoint.Address))
{
if (string.IsNullOrWhiteSpace(endpoint.ChannelFactory))
{
IServiceHelperAttribute configureHelper = new DefaultServiceHelperAttribute();
Binding binding = null;
ClientProxy <I> proxy = null;
EndpointIdentity identity = null;
var attributes = typeof(I).GetCustomAttributes(false);
foreach (var attribute in attributes)
{
if (attribute is IServiceHelperAttribute)
{
configureHelper = attribute as IServiceHelperAttribute;
identity = configureHelper.CreateIdentity();
}
}
if (endpoint.Address.StartsWith("net.tcp://"))
{
binding = new NetTcpBinding()
{
MaxBufferPoolSize = int.MaxValue,
MaxBufferSize = int.MaxValue,
MaxReceivedMessageSize = int.MaxValue,
};
MaxSetter.SetMaxes(binding);
}
else if (endpoint.Address.StartsWith("http://") || endpoint.Address.StartsWith("https://"))
{
binding = new WS2007HttpBinding(SecurityMode.None)
{
MaxBufferPoolSize = int.MaxValue,
MaxReceivedMessageSize = int.MaxValue,
};
MaxSetter.SetMaxes(binding);
MaxSetter.SetTimeouts <I>(binding);
}
else if (endpoint.Address.StartsWith("net.msmq://"))
{
binding = new NetMsmqBinding()
{
MaxBufferPoolSize = int.MaxValue,
MaxReceivedMessageSize = int.MaxValue,
};
}
else if (endpoint.Address.StartsWith("net.pipe://"))
{
binding = new NetNamedPipeBinding()
{
MaxBufferPoolSize = int.MaxValue,
MaxReceivedMessageSize = int.MaxValue,
};
}
configureHelper.ConfigureClientBinding(binding, typeof(I));
proxy = new ClientProxy <I>(
binding,
new EndpointAddress(new Uri(endpoint.Address), configureHelper.CreateIdentity()));
configureHelper.ConfigureClientCredentials(proxy.ClientCredentials, typeof(I));
result = proxy;
}
else
{
var cfType = Type.GetType(endpoint.ChannelFactory);
if (cfType == null)
{
throw new ConfigurationErrorsException("ChannelFactory is invalid");
}
var cf = Activator.CreateInstance(cfType) as ICustomChannelFactory;
if (cf == null)
{
throw new ConfigurationErrorsException("Could not create custom channel factory.");
}
result = cf.CreateChannel <I>(endpoint);
}
}
if (result != null)
{
result.CacheCount = endpoint.CacheCount;
}
return(result);
}
