protected override void OnStart(string[] args)
{
BasicHttpBinding binding = new BasicHttpBinding();
binding.Security.Mode = BasicHttpSecurityMode.Transport;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
try
{
ServiceHost sh = new ServiceHost(typeof(MyService), uri);
sh.AddServiceEndpoint(typeof(IService), binding, "");
ServiceMetadataBehavior smb;
smb = sh.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (smb == null)
{
smb = new ServiceMetadataBehavior()
{
HttpsGetEnabled = true,
};
sh.Description.Behaviors.Add(smb);
}
Binding mexbinding = MetadataExchangeBindings.CreateMexHttpsBinding();
sh.AddServiceEndpoint(typeof(IMetadataExchange), mexbinding, "mex");
sh.Open();
WriteLog($"Service is ready at {DateTime.Now.ToString("hh-mm-ss")}");
}
catch (Exception e)
{
WriteLog(e.ToString());
throw;
}
}
private static MetadataExchangeClient CreateMetadataExchangeClient(EndpointAddress endpointReference)
{
string scheme = endpointReference.Uri.Scheme;
if (string.Compare(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding mexHttpBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpBinding();
mexHttpBinding.MaxReceivedMessageSize = maxReceivedMessageSize;
return(new MetadataExchangeClient(mexHttpBinding));
}
if (string.Compare(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding mexHttpsBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpsBinding();
mexHttpsBinding.MaxReceivedMessageSize = maxReceivedMessageSize;
return(new MetadataExchangeClient(mexHttpsBinding));
}
if (string.Compare(scheme, Uri.UriSchemeNetTcp, StringComparison.OrdinalIgnoreCase) == 0)
{
CustomBinding mexTcpBinding = (CustomBinding)MetadataExchangeBindings.CreateMexTcpBinding();
mexTcpBinding.Elements.Find <TcpTransportBindingElement>().MaxReceivedMessageSize = maxReceivedMessageSize;
return(new MetadataExchangeClient(mexTcpBinding));
}
if (string.Compare(scheme, Uri.UriSchemeNetPipe, StringComparison.OrdinalIgnoreCase) != 0)
{
string message = string.Format("Cannot obtain Metadata from {0}. The URI scheme is not supported by default. Add a client endpoint in config with name=\"\" and contract=\"IMetadataExchange\" and an appropriate binding to obtain Metadata from this URI.", endpointReference.Uri.OriginalString);
throw new ArgumentException(message);
}
CustomBinding mexNamedPipeBinding = (CustomBinding)MetadataExchangeBindings.CreateMexNamedPipeBinding();
mexNamedPipeBinding.Elements.Find <NamedPipeTransportBindingElement>().MaxReceivedMessageSize = maxReceivedMessageSize;
return(new MetadataExchangeClient(mexNamedPipeBinding));
}
/// <summary>
/// Find the wsdl importer
/// </summary>
/// <param name="wsdlUri">The wsdl uri</param>
/// <returns>A wsdl importer</returns>
private WsdlImporter GetWsdlImporter(Uri wsdlUri)
{
_logger.WriteDebug($"GetWsdlImporter wsdlUri[{wsdlUri}]");
WSHttpBinding mexBinding = null;
if (wsdlUri.Scheme == Uri.UriSchemeHttp)
{
mexBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpBinding();
}
else
{
mexBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpsBinding();
}
mexBinding.MaxReceivedMessageSize = Int32.MaxValue;
mexBinding.MaxBufferPoolSize = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxStringContentLength = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxNameTableCharCount = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxArrayLength = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxBytesPerRead = Int32.MaxValue;
mexBinding.ReaderQuotas.MaxDepth = 64;
var mexClient = new MetadataExchangeClient(mexBinding);
mexClient.MaximumResolvedReferences = int.MaxValue;
var metadataSet = mexClient.GetMetadata(wsdlUri, MetadataExchangeClientMode.HttpGet);
return(new WsdlImporter(metadataSet));
}
public ServiceEndpoint HostSecured <T>(ServiceHost host, ServiceInfo serviceInfo)
{
const string addressUriFormat = "{0}://{1}:{2}/{3}/{4}";
string endpointAddress = string.Format(addressUriFormat, "https", serviceInfo.ServerName, serviceInfo.Binding.Configuration.Port,
serviceInfo.Folder,
serviceInfo.ServiceName);
var httpBinding = serviceInfo.Binding.WcfBinding as WSHttpBinding;
var smb = host.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (smb == null)
{
smb = new ServiceMetadataBehavior();
smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15;
host.Description.Behaviors.Add(smb);
}
httpBinding.Security.Mode = SecurityMode.Transport;
httpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
var mexAddress = new Uri(endpointAddress + "MEX");
smb.HttpsGetEnabled = true;
smb.HttpsGetUrl = mexAddress;
var serviceEndpoint = host.AddServiceEndpoint(typeof(T), serviceInfo.Binding.WcfBinding, endpointAddress);
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpsBinding(), mexAddress);
return(serviceEndpoint);
}
public override ServiceHostBase CreateServiceHost
(string service, Uri[] baseAddresses)
{
ServiceHost host = new ServiceHost(typeof(IssHosted.ServiceInterfaces.EchoService),
baseAddresses);
host.AddServiceEndpoint(typeof(IEchoService), new ServiceproviderBinding(true), "");
host.AddServiceEndpoint(typeof(IEchoService), new ServiceproviderBinding(false), "");
// Configure our certificate and issuer certificate validation settings on the service credentials
host.Credentials.ServiceCertificate.SetCertificate(SigningCertificateNameGenevaService, StoreLocation.LocalMachine, StoreName.My);
// Enable metadata generation via HTTP GET
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpsGetEnabled = true;
smb.HttpGetEnabled = true;
host.Description.Behaviors.Add(smb);
host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpsBinding(), "mex");
host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
// Configure the service host to use the Geneva Framework
ServiceConfiguration configuration = new ServiceConfiguration();
configuration.IssuerNameRegistry = new TrustedIssuerNameRegistry();
configuration.SecurityTokenHandlers.Configuration.AudienceRestriction.AllowedAudienceUris.Add(new Uri("http://localhost/Echo/service.svc/Echo"));
configuration.SecurityTokenHandlers.Configuration.AudienceRestriction.AllowedAudienceUris.Add(new Uri("http://localhost:6020/Echo"));
configuration.SecurityTokenHandlers.Configuration.AudienceRestriction.AllowedAudienceUris.Add(new Uri("https://172.30.161.162:8181/poc-provider/ProviderService"));
configuration.SecurityTokenHandlers.Configuration.AudienceRestriction.AllowedAudienceUris.Add(new Uri("https://172.16.232.1:8181/poc-provider/ProviderService"));
configuration.SecurityTokenHandlers.Configuration.AudienceRestriction.AllowedAudienceUris.Add(new Uri("http://csky-pc/test/Service1.svc"));
FederatedServiceCredentials.ConfigureServiceHost(host, configuration);
return(host);
}
public void AddAllMexEndpoint()
{
Debug.Assert(HasMexEndPoint == false);
foreach (Uri baseAddress in BaseAddresses)
{
System.ServiceModel.Channels.Binding binding = null;
switch (baseAddress.Scheme)
{
case "net.tcp":
binding = MetadataExchangeBindings.CreateMexTcpBinding();
break;
case "net.pipe":
binding = MetadataExchangeBindings.CreateMexNamedPipeBinding();
break;
case "http":
binding = MetadataExchangeBindings.CreateMexHttpBinding();
break;
case "https":
binding = MetadataExchangeBindings.CreateMexHttpsBinding();
break;
}
if (binding != null)
{
AddServiceEndpoint(typeof(IMetadataExchange), binding, "Mex");
}
}
}
public void Run()
{
var baseAddress = new Uri("https://localhost:8080/hello");
_host = new ServiceHost(typeof(UserAdmin), baseAddress);
var smb = new ServiceMetadataBehavior
{
HttpsGetEnabled = true,
MetadataExporter = { PolicyVersion = PolicyVersion.Policy15 }
};
_host.Description.Behaviors.Add(smb);
var mexBinding = MetadataExchangeBindings.CreateMexHttpsBinding();
_host.AddServiceEndpoint(
ServiceMetadataBehavior.MexContractName,
mexBinding,
"mex"
);
_host.Credentials.ServiceCertificate.Certificate = new X509Certificate2("c:\\temp\\TempCA.pfx");
var binding = new BasicHttpBinding
{
Security =
{
Mode = BasicHttpSecurityMode.Transport,
}
};
_host.AddServiceEndpoint(typeof(IUserAdmin), binding, "");
_host.Authorization.ServiceAuthorizationManager = new WcfServiceAuthorizationManager();
_host.Description.Behaviors.Find <ServiceDebugBehavior>().IncludeExceptionDetailInFaults = true;
_host.AddDependencyInjectionBehavior <IUserAdmin>(_scope);
_host.Open();
}
public static void AddDefaultMEXEndPoint(this ServiceHost host)
{
const string MexExtension = "Mex";
ServiceMetadataBehavior mexBehavior = new ServiceMetadataBehavior();
host.Description.Behaviors.Add(mexBehavior);
foreach (Uri baseAddress in host.BaseAddresses)
{
if (baseAddress.Scheme == Uri.UriSchemeHttp)
{
mexBehavior.HttpGetEnabled = true;
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(), MexExtension);
}
else if (baseAddress.Scheme == Uri.UriSchemeHttps)
{
mexBehavior.HttpsGetEnabled = true;
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpsBinding(), MexExtension);
}
else if (baseAddress.Scheme == Uri.UriSchemeNetPipe)
{
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexNamedPipeBinding(), MexExtension);
}
else if (baseAddress.Scheme == Uri.UriSchemeNetTcp)
{
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexTcpBinding(), MexExtension);
}
}
}
public void CreateMexHttpsBinding()
{
var b = MetadataExchangeBindings.CreateMexHttpsBinding() as WSHttpBinding;
Assert.IsNotNull(b, "#1");
Assert.AreEqual(SecurityMode.Transport, b.Security.Mode, "#2");
Assert.IsFalse(b.TransactionFlow, "#3");
Assert.IsFalse(b.ReliableSession.Enabled, "#4");
Assert.IsFalse(b.CreateBindingElements().Any(be => be is SecurityBindingElement), "#b1");
Assert.IsTrue(b.CreateBindingElements().Any(be => be is TransactionFlowBindingElement), "#b2");
Assert.IsFalse(b.CreateBindingElements().Any(be => be is ReliableSessionBindingElement), "#b3");
Assert.IsTrue(new TransactionFlowBindingElement().TransactionProtocol == TransactionProtocol.Default, "#x1");
Assert.AreEqual(MessageVersion.Soap12WSAddressing10, b.MessageVersion, "#5");
Assert.AreEqual(MessageVersion.Soap12WSAddressing10, b.GetProperty <MessageVersion>(new BindingParameterCollection()), "#6");
Assert.AreEqual(Uri.UriSchemeHttps, b.Scheme, "#8");
var host = new ServiceHost(typeof(MetadataExchange));
host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpsBinding(), CreateUri("https://localhost:30158"));
host.Open();
try
{
// it still does not rewrite MessageVersion.None. It's rather likely ServiceMetadataExtension which does overwriting.
Assert.AreEqual(MessageVersion.Soap12WSAddressing10, ((ChannelDispatcher)host.ChannelDispatchers[0]).MessageVersion, "#7");
}
finally
{
host.Close();
}
}
SecurityMode SetMexAndSecurity(ServiceHost host,
string mexScheme)
{
ServiceMetadataBehavior mexHttpBehavior = new ServiceMetadataBehavior();
Uri mexUri = new Uri("/mex", UriKind.Relative);
Binding binding;
SecurityMode securityMode;
if (mexScheme == Uri.UriSchemeHttp)
{
mexHttpBehavior.HttpGetEnabled = true;
binding = MetadataExchangeBindings.CreateMexHttpBinding();
securityMode = SecurityMode.Message;
}
else
{
mexHttpBehavior.HttpsGetEnabled = true;
binding = MetadataExchangeBindings.CreateMexHttpsBinding();
securityMode = SecurityMode.TransportWithMessageCredential;
}
host.Description.Behaviors.Add(mexHttpBehavior);
host.AddServiceEndpoint(typeof(IMetadataExchange), binding, mexUri);
return(securityMode);
}
private void addmexbehavior()
{
ServiceMetadataBehavior serviceMetadataBehavior = base.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (serviceMetadataBehavior == null)
{
serviceMetadataBehavior = new ServiceMetadataBehavior();
base.Description.Behaviors.Add(serviceMetadataBehavior);
}
foreach (Uri current in base.BaseAddresses)
{
if (current.Scheme == Uri.UriSchemeHttp)
{
serviceMetadataBehavior.HttpGetEnabled = true;
base.AddServiceEndpoint("IMetadataExchange", MetadataExchangeBindings.CreateMexHttpBinding(), "mex");
}
else if (current.Scheme == Uri.UriSchemeHttps)
{
serviceMetadataBehavior.HttpsGetEnabled = true;
base.AddServiceEndpoint("IMetadataExchange", MetadataExchangeBindings.CreateMexHttpsBinding(), "mex");
}
else if (current.Scheme == Uri.UriSchemeNetPipe)
{
base.AddServiceEndpoint("IMetadataExchange", MetadataExchangeBindings.CreateMexNamedPipeBinding(), "mex");
}
else if (current.Scheme == Uri.UriSchemeNetTcp)
{
base.AddServiceEndpoint("IMetadataExchange", MetadataExchangeBindings.CreateMexTcpBinding(), "mex");
}
}
}
//Overriding ApplyConfiguration() allows us to
//alter the ServiceDescription prior to opening
//the service host.
protected override void ApplyConfiguration()
{
//First, we call base.ApplyConfiguration()
//to read any configuration that was provided for
//the service we're hosting. After this call,
//this.ServiceDescription describes the service
//as it was configured.
base.ApplyConfiguration();
//Now that we've populated the ServiceDescription, we can reach into it
//and do interesting things (in this case, we'll add an instance of
//ServiceMetadataBehavior if it's not already there.
ServiceMetadataBehavior mexBehavior = this.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (mexBehavior == null)
{
mexBehavior = new ServiceMetadataBehavior();
this.Description.Behaviors.Add(mexBehavior);
}
else
{
//Metadata behavior has already been configured,
//so we don't have any work to do.
return;
}
//Add a metadata endpoint at each base address
//using the "/mex" addressing convention
foreach (Uri baseAddress in this.BaseAddresses)
{
if (baseAddress.Scheme == Uri.UriSchemeHttp)
{
mexBehavior.HttpGetEnabled = true;
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeHttps)
{
mexBehavior.HttpsGetEnabled = true;
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpsBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeNetPipe)
{
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexNamedPipeBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeNetTcp)
{
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexTcpBinding(),
"mex");
}
}
}
private void CreateMetadataBehavior(SpringServiceHost ssh, ServiceMetadataBehavior smb, ServiceEndpointElement metadataEle)
{
if (smb == null)
{
smb = new ServiceMetadataBehavior();
if (ssh.BaseAddresses.Any(o => o.Scheme.ToLower() == Uri.UriSchemeHttp))
{
smb.HttpGetEnabled = true;
}
ssh.Description.Behaviors.Add(smb);
}
foreach (var baseAddress in ssh.BaseAddresses)
{
//BindingElement bindingElement = null;
Binding bindingElement = null;
switch (baseAddress.Scheme)
{
case "net.tcp":
{
bindingElement = MetadataExchangeBindings.CreateMexTcpBinding();
//bindingElement = new TcpTransportBindingElement();
break;
}
case "net.pipe":
{
bindingElement = MetadataExchangeBindings.CreateMexNamedPipeBinding();
//bindingElement = new NamedPipeTransportBindingElement();
break;
}
case "http":
{
bindingElement = MetadataExchangeBindings.CreateMexHttpBinding();
//bindingElement = new HttpTransportBindingElement();
break;
}
case "https":
{
bindingElement = MetadataExchangeBindings.CreateMexHttpsBinding();
//bindingElement = new HttpsTransportBindingElement();
break;
}
default:
throw new ProtocolException("The base address {0} Unable to identify".FormatString(baseAddress.ToString()));
}
if (bindingElement != null)
{
//Binding binding = new CustomBinding(bindingElement);
ssh.AddServiceEndpoint(typeof(IMetadataExchange), bindingElement, "MEX");
}
}
}
private void AddWellKnownMexEndpoints(ServiceHost serviceHost)
{
bool relativeAddress;
foreach (var baseAddress in GetBaseAddresses(serviceHost, out relativeAddress))
{
Binding binding = null;
var mexAddress = address;
var scheme = baseAddress.Scheme;
if (StringComparer.OrdinalIgnoreCase.Equals(scheme, Uri.UriSchemeHttp))
{
binding = newBinding ? null : FindCompatibleBinding(serviceHost, scheme);
if (binding == null)
{
binding = MetadataExchangeBindings.CreateMexHttpBinding();
mexAddress = relativeAddress ? string.Empty : baseAddress.AbsoluteUri;
}
}
else if (StringComparer.OrdinalIgnoreCase.Equals(scheme, Uri.UriSchemeHttps))
{
binding = newBinding ? null : FindCompatibleBinding(serviceHost, scheme);
if (binding == null)
{
binding = MetadataExchangeBindings.CreateMexHttpsBinding();
mexAddress = relativeAddress ? string.Empty : baseAddress.AbsoluteUri;
}
}
else if (StringComparer.OrdinalIgnoreCase.Equals(scheme, Uri.UriSchemeNetTcp))
{
binding = MetadataExchangeBindings.CreateMexTcpBinding();
var tcpBinding = new CustomBinding(binding);
var transport = tcpBinding.Elements.OfType <TcpTransportBindingElement>().Single();
transport.PortSharingEnabled = true;
binding = tcpBinding;
if (relativeAddress == false)
{
mexAddress = string.Format("{0}/{1}", baseAddress.AbsoluteUri, address);
}
}
else if (StringComparer.OrdinalIgnoreCase.Equals(scheme, Uri.UriSchemeNetPipe))
{
binding = MetadataExchangeBindings.CreateMexNamedPipeBinding();
if (relativeAddress == false)
{
mexAddress = string.Format("{0}/{1}", baseAddress.AbsoluteUri, address);
}
}
if (binding != null)
{
serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), binding, mexAddress);
}
}
}
/// <summary>
/// Apply configuration
/// </summary>
protected override void ApplyConfiguration()
{
this.Description.ConfigurationName = this.ServiceName;
base.ApplyConfiguration();
ServiceMetadataBehavior mexBehavior = this.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (mexBehavior == null)
{
mexBehavior = new ServiceMetadataBehavior();
this.Description.Behaviors.Add(mexBehavior);
}
else
{
//Metadata behavior has already been configured,
//so we don't have any work to do.
return;
}
//Add a metadata endpoint at each base address
//using the "/mex" addressing convention
foreach (Uri baseAddress in this.BaseAddresses)
{
if (baseAddress.Scheme == Uri.UriSchemeHttp)
{
mexBehavior.HttpGetEnabled = true;
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeHttps)
{
mexBehavior.HttpsGetEnabled = true;
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpsBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeNetPipe)
{
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexNamedPipeBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeNetTcp)
{
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexTcpBinding(),
"mex");
}
}
}
/// <summary>
/// Configures metadata (WSDL) for the service host. The method loops through the
/// base addresses, and adds mex endpoints for http, https, net.tcp and net.pipe
/// addresses, only when no mex endpoints have been previously added by the user.
/// For http and htps addresses, HTTP and HTTPS "Get" mechanism for WSDL retrieval
/// is enabled.
/// </summary>
protected virtual void ConfigureMetadata()
{
if (this.BaseAddresses == null || this.BaseAddresses.Count == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID3140));
}
// Check if a ServiceMetadataBehavior is added.
ServiceMetadataBehavior metadataBehavior = Description.Behaviors.Find <ServiceMetadataBehavior>();
if (metadataBehavior == null)
{
metadataBehavior = new ServiceMetadataBehavior();
Description.Behaviors.Add(metadataBehavior);
}
// Check if an Mex endpoint has alread been added by user. This can be enabled through
// configuration.
bool isMexEndpointAlreadyAdded = (Description.Endpoints.Find(typeof(IMetadataExchange)) != null);
Binding mexBinding = null;
foreach (Uri baseAddress in this.BaseAddresses)
{
if (StringComparer.OrdinalIgnoreCase.Equals(baseAddress.Scheme, Uri.UriSchemeHttp))
{
metadataBehavior.HttpGetEnabled = true;
mexBinding = MetadataExchangeBindings.CreateMexHttpBinding();
}
else if (StringComparer.OrdinalIgnoreCase.Equals(baseAddress.Scheme, Uri.UriSchemeHttps))
{
metadataBehavior.HttpsGetEnabled = true;
mexBinding = MetadataExchangeBindings.CreateMexHttpsBinding();
}
else if (StringComparer.OrdinalIgnoreCase.Equals(baseAddress.Scheme, Uri.UriSchemeNetTcp))
{
mexBinding = MetadataExchangeBindings.CreateMexTcpBinding();
}
else if (StringComparer.OrdinalIgnoreCase.Equals(baseAddress.Scheme, Uri.UriSchemeNetPipe))
{
mexBinding = MetadataExchangeBindings.CreateMexNamedPipeBinding();
}
if (!isMexEndpointAlreadyAdded && (mexBinding != null))
{
AddServiceEndpoint(ServiceMetadataBehavior.MexContractName, mexBinding, "mex");
}
mexBinding = null;
}
}
/// <summary>
/// Adds the mex endpoints.
/// </summary>
/// <param name="host">The service host.</param>
public static void AddMexEndpoints(this ServiceHostBase host)
{
Type T = host.GetType();
var logger = LogManager.GetLogger(T.Name);
var mexBehavior = host.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (mexBehavior == null)
{
mexBehavior = new ServiceMetadataBehavior();
host.Description.Behaviors.Add(mexBehavior);
}
logger.Debug("Checking possible MEX endpoints...");
foreach (Uri baseAddress in host.BaseAddresses)
{
logger.Debug("\tAdding endpoint {0}", baseAddress.AbsoluteUri);
if (baseAddress.Scheme == Uri.UriSchemeNetPipe)
{
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexNamedPipeBinding(),
"mex");
}
if (baseAddress.Scheme == Uri.UriSchemeHttps)
{
if (ConfigurationHelper.SecureMex)
{
mexBehavior.HttpsGetEnabled = true;
mexBehavior.HttpsGetUrl = baseAddress;
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpsBinding(),
"mex");
}
}
if (baseAddress.Scheme == Uri.UriSchemeHttp)
{
if (!ConfigurationHelper.SecureMex)
{
mexBehavior.HttpGetEnabled = true;
mexBehavior.HttpGetUrl = baseAddress;
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(),
"mex");
}
}
if (baseAddress.Scheme == Uri.UriSchemeNetTcp)
{
host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexTcpBinding(),
"mex");
}
}
}
public static MetadataSet GetMetadataSet(string url)
{
MetadataExchangeClientMode mode = MetadataExchangeClientMode.MetadataExchange;
int maxReceivedMessageSize = 3000000;
Uri address = new Uri(url);
System.ServiceModel.Channels.Binding mexBinding = null;
if (string.Compare(address.Scheme, "http", StringComparison.OrdinalIgnoreCase) == 0)
{
mexBinding = MetadataExchangeBindings.CreateMexHttpBinding();
}
else if (string.Compare(address.Scheme, "https", StringComparison.OrdinalIgnoreCase) == 0)
{
mexBinding = MetadataExchangeBindings.CreateMexHttpsBinding();
}
else if (string.Compare(address.Scheme, "net.tcp", StringComparison.OrdinalIgnoreCase) == 0)
{
mexBinding = MetadataExchangeBindings.CreateMexTcpBinding();
}
else if (string.Compare(address.Scheme, "net.pipe", StringComparison.OrdinalIgnoreCase) == 0)
{
mexBinding = MetadataExchangeBindings.CreateMexNamedPipeBinding();
}
else
{
throw new Exception(string.Format("Not supported schema '{0}' for metadata exchange"));
}
if (mexBinding is WSHttpBinding)
{
(mexBinding as WSHttpBinding).MaxReceivedMessageSize = maxReceivedMessageSize;
mode = MetadataExchangeClientMode.HttpGet;
}
else if (mexBinding is CustomBinding)
{
(mexBinding as CustomBinding).Elements.Find <TransportBindingElement>().MaxReceivedMessageSize = maxReceivedMessageSize;
}
else
{
throw new Exception(string.Format("Not supported binding for metadata exchange"));
}
MetadataExchangeClient proxy = new MetadataExchangeClient(mexBinding);
proxy.ResolveMetadataReferences = true;
MetadataSet mds = proxy.GetMetadata(address, mode);
return(mds);
}
static void Main(string[] args)
{
using (ServiceHost host = new ServiceHost(typeof(Service)))
{
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpsGetEnabled = true;
host.Description.Behaviors.Add(smb);
host.AddServiceEndpoint(typeof(IMetadataExchange),
MetadataExchangeBindings.CreateMexHttpsBinding(),
"/mex");
host.Open();
PrintServiceDescription(host);
Console.ReadKey();
}
}
static void Main(string[] args)
{
Uri uri = new Uri("https://localhost:11011");
BasicHttpBinding binding = new BasicHttpBinding();
binding.Security.Mode = BasicHttpSecurityMode.TransportWithMessageCredential;
binding.Security.Message.ClientCredentialType = BasicHttpMessageCredentialType.UserName;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
using (ServiceHost sh = new ServiceHost(typeof(MyService), uri))
{
sh.AddServiceEndpoint(typeof(IService), binding, "");
ServiceMetadataBehavior smb;
smb = sh.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (smb == null)
{
smb = new ServiceMetadataBehavior()
{
HttpsGetEnabled = true
};
sh.Description.Behaviors.Add(smb);
}
sh.Credentials.UserNameAuthentication.UserNamePasswordValidationMode = System.ServiceModel.Security.UserNamePasswordValidationMode.Custom;
sh.Credentials.UserNameAuthentication.CustomUserNamePasswordValidator = new CustUserNamePasswordVal();
Binding mexbinding = MetadataExchangeBindings.CreateMexHttpsBinding();
sh.AddServiceEndpoint(typeof(IMetadataExchange), mexbinding, "mex");
sh.Opened += delegate
{
Console.WriteLine("Service is ready");
};
sh.Closed += delegate
{
Console.WriteLine("Service is clsoed");
};
sh.Open();
Console.ReadLine();
sh.Close();
Console.ReadLine();
}
}
protected override void ApplyConfiguration()
{
base.ApplyConfiguration();
ServiceMetadataBehavior mexBehavior = this.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (mexBehavior != null)
{
return;
}
mexBehavior = new ServiceMetadataBehavior();
this.Description.Behaviors.Add(mexBehavior);
foreach (Uri baseAddress in this.BaseAddresses)
{
if (baseAddress.Scheme == Uri.UriSchemeHttp)
{
mexBehavior.HttpGetEnabled = true;
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeHttps)
{
mexBehavior.HttpsGetEnabled = true;
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexHttpsBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeNetPipe)
{
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexNamedPipeBinding(),
"mex");
}
else if (baseAddress.Scheme == Uri.UriSchemeNetTcp)
{
this.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName,
MetadataExchangeBindings.CreateMexTcpBinding(),
"mex");
}
}
}
private static ServiceHost StartSTS(Type type, string stsLabel, Uri baseAddress, Uri baseMexAddress)
{
// Create the service host
Uri stsAddress = new Uri(baseAddress.AbsoluteUri + "/" + stsLabel);
ServiceHost serviceHost = new ServiceHost(type, stsAddress);
// Don't require derived keys for the issue method
ServiceEndpoint stsEndpoint = serviceHost.Description.Endpoints.Find(typeof(nl.telin.authep.sts.IWSTrustContract));
BindingElementCollection bindingElements = stsEndpoint.Binding.CreateBindingElements();
SecurityBindingElement sbe = bindingElements.Find <SecurityBindingElement>();
RsaSecurityTokenParameters rsaParams = new RsaSecurityTokenParameters();
rsaParams.InclusionMode = SecurityTokenInclusionMode.Never;
rsaParams.RequireDerivedKeys = false;
SupportingTokenParameters requirements = new SupportingTokenParameters();
requirements.Endorsing.Add(rsaParams);
sbe.OptionalOperationSupportingTokenParameters.Add(nl.telin.authep.sts.Constants.WSTrust.Actions.Issue, requirements);
stsEndpoint.Binding = new CustomBinding(bindingElements);
serviceHost.Credentials.ServiceCertificate.Certificate = SigningCertificate;
// Add an https mex listener
string mexAddress = baseMexAddress.AbsoluteUri + "/" + stsLabel + "/mex";
serviceHost.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName, MetadataExchangeBindings.CreateMexHttpsBinding(), mexAddress);
// Disable CRL
serviceHost.Credentials.IssuedTokenAuthentication.RevocationMode = X509RevocationMode.NoCheck;
// Open the service
serviceHost.Open();
// Display the endpoints
foreach (ChannelDispatcher cd in serviceHost.ChannelDispatchers)
{
foreach (EndpointDispatcher ed in cd.Endpoints)
{
Console.WriteLine("Listener = {0}, State = {1}", ed.EndpointAddress.ToString(), cd.State.ToString());
}
}
return(serviceHost);
}
private static MetadataExchangeResolver CreateMetadataExchangeClient(EndpointAddress endpointAddress)
{
MetadataExchangeResolver metadataExchangeClient = null;
string scheme = endpointAddress.Uri.Scheme;
if (String.Compare(scheme, MetadataConstants.Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding binding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpBinding();
binding.MaxReceivedMessageSize = MaxRecievedMexMessageSize;
binding.ReaderQuotas.MaxNameTableCharCount = MaxNameTableCharCount;
binding.ReaderQuotas.MaxDepth = MaxDepth;
binding.ReaderQuotas.MaxBytesPerRead = MaxBytesPerRead;
metadataExchangeClient = new MetadataExchangeResolver(binding);
}
else if (String.Compare(scheme, MetadataConstants.Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding binding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpsBinding();
binding.MaxReceivedMessageSize = MaxRecievedMexMessageSize;
binding.ReaderQuotas.MaxNameTableCharCount = MaxNameTableCharCount;
binding.ReaderQuotas.MaxDepth = MaxDepth;
binding.ReaderQuotas.MaxBytesPerRead = MaxBytesPerRead;
metadataExchangeClient = new MetadataExchangeResolver(binding);
}
else if (String.Compare(scheme, MetadataConstants.Uri.UriSchemeNetTcp, StringComparison.OrdinalIgnoreCase) == 0)
{
CustomBinding binding = (CustomBinding)MetadataExchangeBindings.CreateMexTcpBinding();
binding.Elements.Find <TcpTransportBindingElement>().MaxReceivedMessageSize = MaxRecievedMexMessageSize;
metadataExchangeClient = new MetadataExchangeResolver(binding);
}
else if (String.Compare(scheme, MetadataConstants.Uri.UriSchemeNetPipe, StringComparison.OrdinalIgnoreCase) == 0)
{
CustomBinding binding = (CustomBinding)MetadataExchangeBindings.CreateMexNamedPipeBinding();
binding.Elements.Find <NamedPipeTransportBindingElement>().MaxReceivedMessageSize = MaxRecievedMexMessageSize;
metadataExchangeClient = new MetadataExchangeResolver(binding);
}
else
{
throw new MetadataExchangeException(MetadataResources.ErrCannotCreateAMetadataExchangeClientFormat, endpointAddress.Uri.OriginalString, scheme);
}
return(metadataExchangeClient);
}
static void Main(string[] args)
{
Uri uri = new Uri("https://localhost:21011");
MtomMessageEncodingBindingElement encoding = new MtomMessageEncodingBindingElement();
var transport = new HttpsTransportBindingElement();
transport.TransferMode = TransferMode.Streamed;
var binding = new CustomBinding(encoding, transport);
using (ServiceHost sh = new ServiceHost(typeof(MyService), uri))
{
sh.AddServiceEndpoint(typeof(IService), binding, "");
ServiceMetadataBehavior smb;
smb = sh.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (smb == null)
{
smb = new ServiceMetadataBehavior()
{
HttpsGetEnabled = true
};
sh.Description.Behaviors.Add(smb);
}
Binding mexbinding = MetadataExchangeBindings.CreateMexHttpsBinding();
sh.AddServiceEndpoint(typeof(IMetadataExchange), mexbinding, "mex");
sh.Opened += delegate
{
Console.WriteLine("Service is ready");
};
sh.Closed += delegate
{
Console.WriteLine("Service is clsoed");
};
sh.Open();
Console.ReadLine();
//pause
sh.Close();
Console.ReadLine();
}
}
private static MetadataExchangeClient CreateMetadataExchangeClient(Uri serviceUri)
{
string scheme = serviceUri.Scheme;
MetadataExchangeClient result = null;
if (string.Compare(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding wSHttpBinding = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpBinding();
wSHttpBinding.MaxReceivedMessageSize = 67108864L;
wSHttpBinding.ReaderQuotas.MaxNameTableCharCount = 1048576;
result = new MetadataExchangeClient(wSHttpBinding);
}
else
{
if (string.Compare(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) == 0)
{
WSHttpBinding wSHttpBinding2 = (WSHttpBinding)MetadataExchangeBindings.CreateMexHttpsBinding();
wSHttpBinding2.MaxReceivedMessageSize = 67108864L;
wSHttpBinding2.ReaderQuotas.MaxNameTableCharCount = 1048576;
result = new MetadataExchangeClient(wSHttpBinding2);
}
else
{
if (string.Compare(scheme, Uri.UriSchemeNetTcp, StringComparison.OrdinalIgnoreCase) == 0)
{
CustomBinding tcpBinding = (CustomBinding)MetadataExchangeBindings.CreateMexTcpBinding();
tcpBinding.Elements.Find <TcpTransportBindingElement>().MaxReceivedMessageSize = 67108864L;
result = new MetadataExchangeClient(tcpBinding);
}
else if (string.Compare(scheme, Uri.UriSchemeNetPipe, StringComparison.OrdinalIgnoreCase) != 0)
{
CustomBinding namedPipeBinding = (CustomBinding)MetadataExchangeBindings.CreateMexNamedPipeBinding();
namedPipeBinding.Elements.Find <NamedPipeTransportBindingElement>().MaxReceivedMessageSize = 67108864L;
result = new MetadataExchangeClient(namedPipeBinding);
}
}
}
return(result);
}
private static void RegisterLocalHttpsService(string serviceName, int port, Type serviceType, Type contractType)
{
Console.WriteLine($"Registering {serviceName} service on port {port}");
Console.WriteLine($"netsh http add urlacl url=https://localhost:{port}/{serviceName} user=EVERYONE");
// To be added to package and deploy script;
// netsh http add urlacl url={ServiceUri} user=EVERYONE
var strAdrHttp = $"https://localhost:{port}/{serviceName}";
Uri[] adrbase = { new Uri(strAdrHttp) };
var serviceHost = new ServiceHost(serviceType, adrbase);
var mBehave = new ServiceMetadataBehavior();
serviceHost.Description.Behaviors.Add(mBehave);
var httpb = new BasicHttpBinding();
httpb.Security.Mode = BasicHttpSecurityMode.Transport;
serviceHost.AddServiceEndpoint(contractType, httpb, strAdrHttp);
serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpsBinding(), "mex");
_serviceHosts.Add(serviceHost);
}
/// <summary>
/// https webhttpbinding.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
Uri uri = new Uri("https://localhost:4386");
WebHttpBinding binding = new WebHttpBinding();
binding.Security.Mode = WebHttpSecurityMode.Transport;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
using (WebServiceHost sh = new WebServiceHost(typeof(TestService), uri))
{
sh.AddServiceEndpoint(typeof(ITestService), binding, "");
ServiceMetadataBehavior smb;
smb = sh.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (smb == null)
{
smb = new ServiceMetadataBehavior()
{
//HttpsGetEnabled = true
};
sh.Description.Behaviors.Add(smb);
}
Binding mexbinding = MetadataExchangeBindings.CreateMexHttpsBinding();
sh.AddServiceEndpoint(typeof(IMetadataExchange), mexbinding, "mex");
sh.Opened += delegate
{
Console.WriteLine("service is ready");
};
sh.Closed += delegate
{
Console.WriteLine("service is closed");
};
sh.Open();
Console.ReadLine();
sh.Close();
}
}
private static System.ServiceModel.Channels.Binding CreateMexBindingForScheme(string scheme)
{
if (scheme == null)
{
throw new ArgumentNullException("scheme");
}
if (string.Compare(scheme, "http", StringComparison.OrdinalIgnoreCase) == 0)
{
return(MetadataExchangeBindings.CreateMexHttpBinding());
}
if (string.Compare(scheme, "https", StringComparison.OrdinalIgnoreCase) == 0)
{
return(MetadataExchangeBindings.CreateMexHttpsBinding());
}
if (string.Compare(scheme, "net.pipe", StringComparison.OrdinalIgnoreCase) == 0)
{
return(MetadataExchangeBindings.CreateMexNamedPipeBinding());
}
if (string.Compare(scheme, "net.tcp", StringComparison.OrdinalIgnoreCase) == 0)
{
return(MetadataExchangeBindings.CreateMexTcpBinding());
}
throw new ArgumentException(string.Format("MEX for scheme {0} is not supported.", scheme));
}
/// <summary>
/// Static Method GetBinding.
/// </summary>
/// <param name="address">Binding address.</param>
/// <param name="isMexBinding">Whether the binding is mex.</param>
/// <returns>Instance of Binding.</returns>
internal static Binding GetBinding(string address, bool isMexBinding)
{
if (isMexBinding)
{
if (address.StartsWith("mexNamedPipeBinding"))
{
return(MetadataExchangeBindings.CreateMexNamedPipeBinding());
}
if (address.StartsWith("mexTcpBinding"))
{
return(MetadataExchangeBindings.CreateMexTcpBinding());
}
if (address.StartsWith("mexHttpBinding"))
{
return(MetadataExchangeBindings.CreateMexHttpBinding());
}
if (address.StartsWith("mexHttpsBinding"))
{
return(MetadataExchangeBindings.CreateMexHttpsBinding());
}
}
else
{
if (address.StartsWith("netNamedPipeBinding"))
{
return(new NetNamedPipeBinding());
}
if (address.StartsWith("netTcpBinding"))
{
return(new NetTcpBinding());
}
if (address.StartsWith("customBinding"))
{
return(new CustomBinding());
}
if (address.StartsWith("basicHttpBinding"))
{
return(new BasicHttpBinding());
}
if (address.StartsWith("wsHttpBinding"))
{
return(new WSHttpBinding());
}
if (address.StartsWith("ws2007HttpBinding"))
{
return(new WS2007HttpBinding());
}
if (address.StartsWith("ws2007FederationHttpBinding"))
{
return(new WS2007FederationHttpBinding());
}
if (address.StartsWith("wsDualHttpBinding"))
{
return(new WSDualHttpBinding());
}
if (address.StartsWith("wsFederationHttpBinding"))
{
return(new WSFederationHttpBinding());
}
}
return(null);
}
/// <summary>
/// Gets the Binding instance according to a Binding type name.
/// </summary>
/// <param name="bindingTypeName">The name of <see cref="T:System.ServiceModel.Channels.Binding" /> for the service.</param>
/// <returns>Instance of Binding.</returns>
public static Binding GetBinding(string bindingTypeName)
{
if (bindingTypeName.Equals("BasicHttpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new BasicHttpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxBufferSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("WSHttpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new WSHttpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("NetTcpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new NetTcpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxBufferSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ListenBacklog = int.MaxValue, MaxConnections = ushort.MaxValue, PortSharingEnabled = true, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("NetNamedPipeBinding", StringComparison.OrdinalIgnoreCase))
{
return(new NetNamedPipeBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxBufferSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, MaxConnections = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("WS2007HttpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new WS2007HttpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("WS2007FederationHttpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new WS2007FederationHttpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("WSDualHttpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new WSDualHttpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("WSFederationHttpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new WSFederationHttpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("NetMsmqBinding", StringComparison.OrdinalIgnoreCase))
{
return(new NetMsmqBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("NetPeerTcpBinding", StringComparison.OrdinalIgnoreCase))
{
return(new NetPeerTcpBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10), MaxBufferPoolSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReaderQuotas = XmlDictionaryReaderQuotas.Max
});
}
if (bindingTypeName.Equals("CustomBinding", StringComparison.OrdinalIgnoreCase))
{
return(new CustomBinding()
{
OpenTimeout = TimeSpan.FromMinutes(10), CloseTimeout = TimeSpan.FromMinutes(10), SendTimeout = TimeSpan.FromMinutes(10), ReceiveTimeout = TimeSpan.FromMinutes(10)
});
}
if (bindingTypeName.Equals("MetadataExchangeBindings", StringComparison.OrdinalIgnoreCase))
{
return(MetadataExchangeBindings.CreateMexNamedPipeBinding());
}
if (bindingTypeName.Equals("MetadataExchangeBindings", StringComparison.OrdinalIgnoreCase))
{
return(MetadataExchangeBindings.CreateMexTcpBinding());
}
if (bindingTypeName.Equals("MetadataExchangeBindings", StringComparison.OrdinalIgnoreCase))
{
return(MetadataExchangeBindings.CreateMexHttpBinding());
}
if (bindingTypeName.Equals("MetadataExchangeBindings", StringComparison.OrdinalIgnoreCase))
{
return(MetadataExchangeBindings.CreateMexHttpsBinding());
}
return(null);
}