static void Main(string[] args)
        {
            try
            {
                ServiceHost dataExchangeService = null;
                Uri httpBaseAddress = new Uri(args.Length == 0 ? "http://127.0.0.1:8080" : args[0]);

                dataExchangeService = new ServiceHost(typeof(Service), httpBaseAddress);
                WSHttpBinding binding = new WSHttpBinding();
                binding.Security = new WSHttpSecurity { Mode = SecurityMode.None };

                binding.Security.Transport = new HttpTransportSecurity { ClientCredentialType = HttpClientCredentialType.None };
                binding.MaxBufferPoolSize = 1073741824;
                binding.MaxReceivedMessageSize = 1073741824;
                binding.ReceiveTimeout = TimeSpan.FromHours(1);
                binding.SendTimeout = TimeSpan.FromHours(1);
                binding.ReaderQuotas.MaxArrayLength = 1073741824;
                binding.ReaderQuotas.MaxBytesPerRead = 1073741824;
                binding.ReaderQuotas.MaxDepth = 1073741824;
                binding.ReaderQuotas.MaxStringContentLength = 1073741824;

                dataExchangeService.AddServiceEndpoint(typeof(IDataTranslation), binding, "");
                dataExchangeService.AddServiceEndpoint(typeof(IDataSimulation), binding, "");
                dataExchangeService.Open();
                logger.log("Service is now at: " + httpBaseAddress);
                while (true)
                {
                    Thread.Sleep(10000);
                }
            }
            catch (Exception ex)
            {
                logger.log( ex.Message, Logger.LogType.ERROR);
            }
        }

        private static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof (EvalService));

            WSHttpBinding noSecurityPlusRMBinding = new WSHttpBinding();
            noSecurityPlusRMBinding.Security.Mode = SecurityMode.None;
            noSecurityPlusRMBinding.ReliableSession.Enabled = true;

            host.AddServiceEndpoint(typeof (IEvalService), new BasicHttpBinding(), "http://localhost:8080/evals/basic");
            host.AddServiceEndpoint(typeof(IEvalService), noSecurityPlusRMBinding, "http://localhost:8080/evals/ws");
            //host.AddServiceEndpoint(typeof (IEvalService), new NetTcpBinding(), "net.tcp://localhost:8081/evals");

            ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
            smb.HttpGetEnabled = true;
            smb.HttpGetUrl = new Uri("http://localhost:8080/evals/basic/meta");
            host.Description.Behaviors.Add(smb);

            try
            {
                host.Open();
                PrintServiceInfo(host);
                Console.ReadLine();
                host.Close();

            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                host.Abort();
            }

            Console.ReadLine();
        }

        static void Main(string[] args)
        {
            Uri baseAddress = new Uri("http://localhost:8773/WSHttpService");

            WSHttpBinding binding = new WSHttpBinding();

            binding.Name = "WSHttp_Binding";
            binding.HostNameComparisonMode = HostNameComparisonMode.WeakWildcard;
            CustomBinding customBinding = new CustomBinding(binding);
            SymmetricSecurityBindingElement securityBinding = (SymmetricSecurityBindingElement)customBinding.Elements.Find<SecurityBindingElement>();

            /// Change the MaxClockSkew to 2 minutes on both service and client settings.
            TimeSpan newClockSkew = new TimeSpan(0, 2, 0);

            securityBinding.LocalServiceSettings.MaxClockSkew = newClockSkew;
            securityBinding.LocalClientSettings.MaxClockSkew = newClockSkew;

            using (ServiceHost host = new ServiceHost(typeof(WSHttpService), baseAddress))
            {
                host.AddServiceEndpoint(typeof(IWSHttpService), customBinding, "http://localhost:8773/WSHttpService/mex");
                // Enable metadata publishing.
                ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
                smb.HttpGetEnabled = true;
                smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15;
                host.Description.Behaviors.Add(smb);
                host.Open();

                Console.WriteLine("The service is ready at {0}", baseAddress);
                Console.WriteLine("Press <Enter> to stop the service.");
                Console.ReadLine();

                // Close the ServiceHost.
                host.Close();
            }
        }

	public static void Main ()
	{
		ServiceHost host = new ServiceHost (typeof (Foo));
		WSHttpBinding binding = new WSHttpBinding ();
		binding.Security.Message.EstablishSecurityContext = false;
		binding.Security.Message.NegotiateServiceCredential = false;
		binding.Security.Message.ClientCredentialType = MessageCredentialType.Certificate;
		binding.ReceiveTimeout = TimeSpan.FromSeconds (5);
		host.AddServiceEndpoint ("IFoo",
			binding, new Uri ("http://localhost:8080"));
		ServiceCredentials cred = new ServiceCredentials ();
		cred.ServiceCertificate.Certificate =
			new X509Certificate2 ("test.pfx", "mono");
		cred.ClientCertificate.Authentication.CertificateValidationMode =
			X509CertificateValidationMode.None;
		host.Description.Behaviors.Add (cred);
		host.Description.Behaviors.Find<ServiceDebugBehavior> ()
			.IncludeExceptionDetailInFaults = true;
		foreach (ServiceEndpoint se in host.Description.Endpoints)
			se.Behaviors.Add (new StdErrInspectionBehavior ());
		ServiceMetadataBehavior smb = new ServiceMetadataBehavior ();
		smb.HttpGetEnabled = true;
		smb.HttpGetUrl = new Uri ("http://localhost:8080/wsdl");
		host.Description.Behaviors.Add (smb);
		host.Open ();
		Console.WriteLine ("Hit [CR] key to close ...");
		Console.ReadLine ();
		host.Close ();
	}

        static void Main(string[] args)
        {
            // Configure IoC
            Container.Register(
                Component.For<IStockLookup>()
                .ImplementedBy<StockLookup>());

            // Configure Host
            using (var host = new ServiceHost(
                typeof(StockLookup),
                new Uri("http://localhost:1701/")))
            {
                var binding = new WSHttpBinding();
                var ep = host.AddServiceEndpoint(
                    typeof(IStockLookup),   // Contract
                    binding,                // Binding
                    "Stock");               // Address

                var ioc = new WindsorServiceBehavior();
                host.Description.Behaviors.Add(ioc);

                host.Open();
                Console.WriteLine("Host is now running...");
                Console.WriteLine(">>> Press Enter To Stop <<<");
                Console.ReadLine();
                host.Close();
            }
        }

        static void Main(string[] args)
        {
            var baseAddress = new Uri("https://localhost:44355");

            using (var host = new ServiceHost(typeof(HelloWorldService), baseAddress))
            {
                var binding = new WSHttpBinding(SecurityMode.Transport);
                binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;

                host.Credentials.ServiceCertificate.SetCertificate(StoreLocation.LocalMachine, StoreName.My, X509FindType.FindBySubjectName, "localhost");
                host.Credentials.ClientCertificate.Authentication.RevocationMode = X509RevocationMode.NoCheck;
                host.Credentials.ClientCertificate.Authentication.TrustedStoreLocation = StoreLocation.LocalMachine;
                host.Credentials.ClientCertificate.Authentication.CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.ChainTrust;

                var endpoint = typeof(IHelloWorldService);
                host.AddServiceEndpoint(endpoint, binding, baseAddress);

                var metaBehavior = new ServiceMetadataBehavior();
                metaBehavior.HttpGetEnabled = true;
                metaBehavior.HttpGetUrl = new Uri("http://localhost:9000/mex");
                metaBehavior.MetadataExporter.PolicyVersion = PolicyVersion.Policy15;
                host.Description.Behaviors.Add(metaBehavior);

                host.Open();

                Console.WriteLine("Service is ready. Hit enter to stop service.");
                Console.ReadLine();

                host.Close();
            }
        }

        public void ConfigureServiceHost(ServiceHost host, ServiceHostConfigurationArgs args)
        {
            WSHttpBinding binding = new WSHttpBinding();
            binding.MaxReceivedMessageSize = args.MaxReceivedMessageSize;
            binding.ReaderQuotas.MaxStringContentLength = args.MaxReceivedMessageSize;
            binding.ReaderQuotas.MaxArrayLength = args.MaxReceivedMessageSize;
            binding.Security.Mode = WebServicesSettings.Default.SecurityMode;
            binding.Security.Message.ClientCredentialType = args.Authenticated
                                                                ? MessageCredentialType.UserName
                                                                : MessageCredentialType.None;
            // establish endpoint
            host.AddServiceEndpoint(args.ServiceContract, binding, "");

            // expose meta-data via HTTP GET
            ServiceMetadataBehavior metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();
            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                metadataBehavior.HttpGetEnabled = true;
                host.Description.Behaviors.Add(metadataBehavior);
            }

            // set up the certificate 
            if (WebServicesSettings.Default.SecurityMode == SecurityMode.Message 
                || WebServicesSettings.Default.SecurityMode==SecurityMode.TransportWithMessageCredential)
            {
                host.Credentials.ServiceCertificate.SetCertificate(
                    StoreLocation.LocalMachine, StoreName.My, X509FindType.FindBySubjectName, args.HostUri.Host);
            }
        }

 public static SGDatabase_HClient CreateSGDatabase_HClient()
 {
     WSHttpBinding BINDING = new WSHttpBinding();
     WcfClientConfig.ReadBindingConfig(BINDING, "WSHttpBinding_SGDatabase_H");//从配置文件(app.config)读取配置。
     string endpoint = WcfClientConfig.GetWcfRemoteAddress("WSHttpBinding_SGDatabase_H");
     return new SGDatabase_HClient(BINDING, new EndpointAddress(endpoint));
 }

        public static WSHttpBinding GetHttpBinding()
        {
            var binding = new WSHttpBinding
            {
                MaxBufferPoolSize = 2147483647,
                MaxReceivedMessageSize = 2147483647,
                MessageEncoding = WSMessageEncoding.Mtom,
                TextEncoding = System.Text.Encoding.UTF8,
                ReceiveTimeout = new TimeSpan(0, 0, 1, 0),
                SendTimeout = new TimeSpan(0, 0, 1, 0),
                OpenTimeout = new TimeSpan(0, 0, 1, 0),
                ReaderQuotas =
                {
                    MaxArrayLength = 2147483647,
                    MaxDepth = 2147483647,
                    MaxStringContentLength = 2147483647,
                    MaxBytesPerRead = 2147483647,
                    MaxNameTableCharCount = 2147483647
                },
                ReliableSession = { Enabled = true, InactivityTimeout = new TimeSpan(0, 0, 1, 0) },
                Security = { Mode = SecurityMode.None , Transport = {ClientCredentialType = HttpClientCredentialType.None}}
            };

            return binding;
        }

 static IFileService CreateChannel(string url)
 {
     WSHttpBinding binding = new WSHttpBinding();
       EndpointAddress address = new EndpointAddress(url);
       ChannelFactory<IFileService> factory = new ChannelFactory<IFileService>(binding, address);
       return factory.CreateChannel();
 }

        public void Start()
        {
            this.host = new ServiceHost(typeof(NotificationService));

            var binding = new WSHttpBinding
                          {
                              Security =
                              {
                                  Mode = SecurityMode.None
                              }
                          };

            var behavior = new ServiceMetadataBehavior
                           {
                               HttpGetEnabled = true,
                               HttpGetUrl = configuration.Uri
                           };

            this.host.AddServiceEndpoint(typeof(INotificationService), binding, configuration.Uri);

            this.host.AddDependencyInjectionBehavior<NotificationService>(this.container);

            this.host.Description.Behaviors.Add(behavior);

            this.host.Open();
        }

        public void CanProvideInstanceForHost()
        {
            using (var container = new UnityContainer())
            {
                //var serviceMock = new Mock<ITestService>();
                //container.RegisterInstance<ITestService>(serviceMock.Object);
                container.RegisterInstance<TestService>(new TestService("Test"));

                var serviceHost = new ServiceHost(typeof(TestService), new Uri("http://localhost:55551/TestService"));
                serviceHost.Description.Behaviors.Add(new UnityServiceBehavior(container));

                Binding binding = new WSHttpBinding();
                var address = new EndpointAddress("http://localhost:55551/TestService/MyService");
                var endpoint = serviceHost
                    .AddServiceEndpoint(typeof(ITestService), binding, address.Uri);

                var smb = new ServiceMetadataBehavior { HttpGetEnabled = true };
                serviceHost.Description.Behaviors.Add(smb);

                var proxy = ChannelFactory<ITestService>.CreateChannel(binding, endpoint.Address);

                serviceHost.Open();

                var result = proxy.TestOperation();

                serviceHost.Close();

                Assert.AreEqual("Test", result);
            }
        }

        /// <summary>
        /// A private function to create the soapclient to communicate with ServiceNOW
        /// </summary>
        /// <param name="UserName">The API Username</param>
        /// <param name="Password">The API Password</param>
        /// <returns>A ServiceNow SoapClient object</returns>
        private static ServiceNowSoapClient soapClient(string UserName, string Password, string ServiceNowUrl)
        {
            try
            {
                EndpointAddress endpoint = new EndpointAddress(new Uri(ServiceNowUrl));
                WSHttpBinding binding = new WSHttpBinding();

                binding.Name = "ServiceNowSoap";
                binding.MaxReceivedMessageSize = 65536;
                binding.Security.Mode = SecurityMode.Transport;
                binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
                binding.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.Basic;
                binding.Security.Message.ClientCredentialType = MessageCredentialType.UserName;

                ServiceNowSoapClient soapClient = new ServiceNowSoapClient(binding, endpoint);
                soapClient.ClientCredentials.UserName.UserName = UserName;
                soapClient.ClientCredentials.UserName.Password = Password;

                return soapClient;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return null;
            }
        }

 public static SGDatabase_WClient CreateSGDatabase_WClient()
 {
     WSHttpBinding BINDING = new WSHttpBinding();
     SoapClientConfig.ReadBindingConfig(BINDING, "http_ISGDatabase_W");//从配置文件(app.config)读取配置。
     string endpoint = SoapClientConfig.GetSoapRemoteAddress("http_ISGDatabase_W");
     return new SGDatabase_WClient(BINDING, new EndpointAddress(endpoint));//构建WCF客户端实例
 }

		/// <summary>
		/// Configures the specified service host, according to the specified arguments.
		/// </summary>
		/// <param name="host"></param>
		/// <param name="args"></param>
		public void ConfigureServiceHost(ServiceHost host, ServiceHostConfigurationArgs args)
		{
			var binding = new WSHttpBinding();
			binding.MaxReceivedMessageSize = args.MaxReceivedMessageSize;
			if (args.SendTimeoutSeconds > 0)
				binding.SendTimeout = TimeSpan.FromSeconds(args.SendTimeoutSeconds);

			binding.ReaderQuotas.MaxStringContentLength = args.MaxReceivedMessageSize;
			binding.ReaderQuotas.MaxArrayLength = args.MaxReceivedMessageSize;
			binding.Security.Mode = SecurityMode.Message;
			binding.Security.Message.ClientCredentialType = args.Authenticated ?
				MessageCredentialType.UserName : MessageCredentialType.None;

			// establish endpoint
			host.AddServiceEndpoint(args.ServiceContract, binding, "");

			// expose meta-data via HTTP GET
			var metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();
			if (metadataBehavior == null)
			{
				metadataBehavior = new ServiceMetadataBehavior();
				metadataBehavior.HttpGetEnabled = true;
				host.Description.Behaviors.Add(metadataBehavior);
			}

			//TODO (Rockstar): remove this after refactoring to do per-sop edits
			foreach (var endpoint in host.Description.Endpoints)
				foreach (var operation in endpoint.Contract.Operations)
					operation.Behaviors.Find<DataContractSerializerOperationBehavior>().MaxItemsInObjectGraph = args.MaxReceivedMessageSize;

			// set up the certificate - required for WSHttpBinding
			host.Credentials.ServiceCertificate.SetCertificate(
				args.CertificateSearchDirective.StoreLocation, args.CertificateSearchDirective.StoreName,
				args.CertificateSearchDirective.FindType, args.CertificateSearchDirective.FindValue);
		}

        /// <summary>
        /// 启动服务
        /// </summary>
        private void OpenWCFServer()
        {
            WSHttpBinding wsHttp = new WSHttpBinding();
            wsHttp.MaxBufferPoolSize = 524288;
            wsHttp.MaxReceivedMessageSize = 2147483647;
            wsHttp.ReaderQuotas.MaxArrayLength = 6553600;
            wsHttp.ReaderQuotas.MaxStringContentLength = 2147483647;
            wsHttp.ReaderQuotas.MaxBytesPerRead = 6553600;
            wsHttp.ReaderQuotas.MaxDepth = 6553600;
            wsHttp.ReaderQuotas.MaxNameTableCharCount = 6553600;
            wsHttp.CloseTimeout = new TimeSpan(0, 1, 0);
            wsHttp.OpenTimeout = new TimeSpan(0, 1, 0);
            wsHttp.ReceiveTimeout = new TimeSpan(0, 10, 0);
            wsHttp.SendTimeout = new TimeSpan(0, 10, 0);
            wsHttp.Security.Mode = SecurityMode.None;

            Uri baseAddress = new Uri("http://127.0.0.1:9999/wcfserver");
            ServiceHost host = new ServiceHost(typeof(WCFServer), baseAddress);

            ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
            smb.HttpGetEnabled = true;
            host.Description.Behaviors.Add(smb);

            ServiceBehaviorAttribute sba = host.Description.Behaviors.Find<ServiceBehaviorAttribute>();
            sba.MaxItemsInObjectGraph = 2147483647;

            host.AddServiceEndpoint(typeof(IWCFServer), wsHttp, "");

            host.Open();
        }

        static LegacyProvider()
        {
            WSHttpBinding wsHttpBinding = new WSHttpBinding()
            {
                Security = new WSHttpSecurity()
                {
                    Mode = SecurityMode.Message,
                    Message =
                    {
                        ClientCredentialType = MessageCredentialType.Windows
                    }
                }
            };

            EndpointAddress endpoint = new EndpointAddress(VirtualPathUtility.AppendTrailingSlash(DebuggerConfig.Instance.CMS.Url) + "webservices/CoreService2011.svc/wsHttp");
            ChannelFactory<core.ICoreService> clientFactory = new ChannelFactory<core.ICoreService>(wsHttpBinding, endpoint)
            {
                Credentials =
                {
                    Windows =
                    {
                        ClientCredential = CredentialCache.DefaultNetworkCredentials
                    }
                }
            };

            // Initialize the CoreServiceClient
            mCoreServiceClient = clientFactory.CreateChannel();
        }

 public static Object GetWcfReference(Type type, object[] info)
 {
   if (info.Length == 2)
     info = new object[] { info[0], null, info[1] };
   if (info.Length != 3)
     return null;
   Type genType;
   Type factType;
   if (info[0] == null)
   {
     genType = typeof(ChannelFactory<>);
     factType = genType.MakeGenericType(new Type[] { type });
     if (info[1] == null)
       info[1] = new WSHttpBinding();
     info = new object[] { info[1], new EndpointAddress((string)info[2]) };
   }
   else
   {
     genType = typeof(DuplexChannelFactory<>);
     factType = genType.MakeGenericType(new Type[] { type });
     info[0] = new InstanceContext(info[0]);
     info[2] = new EndpointAddress((string)info[2]);
     if (info[1] == null)
       info[1] = new WSDualHttpBinding();
   }
   object factObject = Activator.CreateInstance(factType, info);
   MethodInfo methodInfo = factType.GetMethod("CreateChannel", new Type[] { });
   return methodInfo.Invoke(factObject, null);
 }

        // Host the service within this EXE console application.
        public static void Main()
        {
            WSHttpBinding binding = new WSHttpBinding();
            binding.Name = "binding1";
            binding.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
            binding.Security.Mode = SecurityMode.Message;
            binding.ReliableSession.Enabled = false;
            binding.TransactionFlow = false;
            
            Uri baseAddress = new Uri("http://localhost:8000/servicemodelsamples/service");

            // Create a ServiceHost for the CalculatorService type and provide the base address.
            using(ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress))
            {
                serviceHost.AddServiceEndpoint(typeof(ICalculator), binding, baseAddress);
                // Open the ServiceHostBase to create listeners and start listening for messages.
                serviceHost.Open();

                // The service can now be accessed.
                Console.WriteLine("The service is ready.");
                Console.WriteLine("Press <ENTER> to terminate service.");
                Console.WriteLine();
                Console.ReadLine();
                             
            }
                    
        }

		/// <summary>
		/// Configures the specified service host, according to the specified arguments.
		/// </summary>
		/// <param name="host"></param>
		/// <param name="args"></param>
		public void ConfigureServiceHost(ServiceHost host, ServiceHostConfigurationArgs args)
		{
			WSHttpBinding binding = new WSHttpBinding();
			binding.MaxReceivedMessageSize = args.MaxReceivedMessageSize;
            binding.ReaderQuotas.MaxStringContentLength = args.MaxReceivedMessageSize;
            binding.ReaderQuotas.MaxArrayLength = args.MaxReceivedMessageSize;
			binding.Security.Mode = SecurityMode.Message;
			binding.Security.Message.ClientCredentialType = args.Authenticated ?
				MessageCredentialType.UserName : MessageCredentialType.None;

			// establish endpoint
			host.AddServiceEndpoint(args.ServiceContract, binding, "");

			// expose meta-data via HTTP GET
			ServiceMetadataBehavior metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();
			if (metadataBehavior == null)
			{
				metadataBehavior = new ServiceMetadataBehavior();
				metadataBehavior.HttpGetEnabled = true;
				host.Description.Behaviors.Add(metadataBehavior);
			}

			// set up the certificate - required for WSHttpBinding
            host.Credentials.ServiceCertificate.SetCertificate(
                args.CertificateSearchDirective.StoreLocation, args.CertificateSearchDirective.StoreName,
                args.CertificateSearchDirective.FindType, args.CertificateSearchDirective.FindValue);
		}