C# Web.WebServiceHost類代碼示例

        protected int _init()
        {
            try
            {
                this._baseAddress = new Uri(this._configuration.Address);
                this._baseHost = new WebServiceHost(this._serverPrimaryType, this._baseAddress);                

                this._metadataBehaviour = new ServiceMetadataBehavior();
                this._metadataBehaviour.HttpGetEnabled = true;
                this._metadataBehaviour.HttpGetUrl = this._baseAddress;
                this._baseHost.Description.Behaviors.Add(this._metadataBehaviour);                

                this._basicBinding = new BasicHttpBinding();
                this._basicBinding.MaxBufferPoolSize = Int32.MaxValue;
                this._basicBinding.MaxReceivedMessageSize = Int32.MaxValue;
                this._basicBinding.MaxBufferSize = Int32.MaxValue;
                this._basicBinding.TransferMode = TransferMode.Streamed;
                this._basicBinding.ReaderQuotas.MaxArrayLength = int.MaxValue;
                this._basicBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
                this._basicBinding.ReaderQuotas.MaxBytesPerRead = int.MaxValue;
                this._basicBinding.ReaderQuotas.MaxDepth = 32;
                this._basicBinding.ReaderQuotas.MaxNameTableCharCount = int.MaxValue;

                if (this._allowWebRequests)
                {
                    this._webBehaviour = new WebHttpBehavior();

                    this._webBinding = new WebHttpBinding();
                    this._webBinding.MaxBufferPoolSize = Int32.MaxValue;
                    this._webBinding.MaxReceivedMessageSize = Int32.MaxValue;
                    this._webBinding.MaxBufferSize = Int32.MaxValue;
                    this._webBinding.TransferMode = TransferMode.Streamed;
                    this._webBinding.ReaderQuotas.MaxArrayLength = int.MaxValue;
                    this._webBinding.ReaderQuotas.MaxStringContentLength = int.MaxValue;
                    this._webBinding.ReaderQuotas.MaxBytesPerRead = int.MaxValue;
                    this._webBinding.ReaderQuotas.MaxDepth = 32;
                    this._webBinding.ReaderQuotas.MaxNameTableCharCount = int.MaxValue;
                }
            }
            catch (Exception ex)
            { 
                return -2;
            }

            try
            {
                this._baseHost.AddServiceEndpoint(this._serverInterfaceType, this._basicBinding, this._configuration.Address);
                if (this._allowWebRequests)
                {                                        
                    var Endpoint = this._baseHost.AddServiceEndpoint(_serverInterfaceType, this._webBinding, "Web");
                    Endpoint.Behaviors.Add(this._webBehaviour);
                }
            }
            catch (Exception ex)
            { 
                return -2;
            }

            return -1;
        }

        protected override void OnStart(string[] args)
        {
            var sn = "Facturador Fiscal Winks Hotel";

            try
            {
                Uri baseAddress = new Uri(ConfigurationManager.AppSettings["BaseAddress"]);

                var webHost = new WebServiceHost(typeof(ServiceSelector), baseAddress);
                var endpoint = webHost.AddServiceEndpoint(typeof(IServiceSelector), new WebHttpBinding(WebHttpSecurityMode.None), baseAddress);
                //add support for cors (both for the endpoint to detect and create reply)
                endpoint.Behaviors.Add(new CorsBehaviorAttribute());

                foreach (var operation in endpoint.Contract.Operations)
                {
                    //add support for cors (and for operation to be able to not
                    //invoke the operation if we have a preflight cors request)
                    operation.Behaviors.Add(new CorsBehaviorAttribute());
                }

                webHost.Open();
            }
            catch (Exception ex)
            {
                if (!EventLog.SourceExists(sn))
                    EventLog.CreateEventSource(sn, "Application");

                EventLog.WriteEntry(sn, ex.Message, EventLogEntryType.Error);
            }
        }

        static void Main(string[] args)
        {
            WebServiceHost webServiceHost = new WebServiceHost(typeof(PartyService.Service));

            WebHttpBinding serviceBinding = new WebHttpBinding(WebHttpSecurityMode.TransportCredentialOnly);
            serviceBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
            ServiceEndpoint ep = webServiceHost.AddServiceEndpoint(
                typeof(PartyService.IService),
                serviceBinding,
                "http://localhost:8000/service");
            ep.Behaviors.Add(new PartyService.ProcessorBehaviour());

            WebHttpBinding staticBinding = new WebHttpBinding(WebHttpSecurityMode.None);
            ServiceEndpoint sep = webServiceHost.AddServiceEndpoint(
                typeof(PartyService.IStaticItemService),
                new WebHttpBinding(),
                "http://localhost:8000");

            webServiceHost.Credentials.UserNameAuthentication.UserNamePasswordValidationMode = UserNamePasswordValidationMode.Custom;
            webServiceHost.Credentials.UserNameAuthentication.CustomUserNamePasswordValidator = new PartyService.Validator();
            webServiceHost.Description.Behaviors.Find<ServiceDebugBehavior>().IncludeExceptionDetailInFaults = true;

            webServiceHost.Open();
            Console.WriteLine("Service is running - press enter to quit");
            Console.ReadLine();
            webServiceHost.Close();
            Console.WriteLine("Service stopped");
        }

 protected override void OnStart(string[] args)
 {
     var host = new WebServiceHost(new NancyWcfGenericService(),
                       new Uri("http://localhost:1234/base/"));
      host.AddServiceEndpoint(typeof(NancyWcfGenericService), new WebHttpBinding(), "");
      host.Open();
 }

        public async Task Run(string hostName, string listenToken)
        {
            string httpAddress = new UriBuilder("http", hostName, -1, "svc").ToString();
            using (var host = new WebServiceHost(GetType()))
            {
                host.AddServiceEndpoint(
                    GetType(),
                    new WebHttpRelayBinding(
                        EndToEndWebHttpSecurityMode.None,
                        RelayClientAuthenticationType.None) {IsDynamic = true},
                    httpAddress)
                    .EndpointBehaviors.Add(
                        new TransportClientEndpointBehavior(
                            TokenProvider.CreateSharedAccessSignatureTokenProvider(listenToken)));

                host.Open();

                Console.WriteLine("Starting a browser to see the image: ");
                Console.WriteLine(httpAddress + "/Image");
                Console.WriteLine();
                // launching the browser
                System.Diagnostics.Process.Start(httpAddress + "/Image");
                Console.WriteLine("Press [Enter] to exit");
                Console.ReadLine();

                host.Close();
            }
        }

		static void Main (string[] args) {
			LegoRestService DemoServices = new LegoRestService ();
			WebServiceHost _serviceHost = new WebServiceHost (DemoServices, new Uri ("http://localhost:8000/DEMOService"));
			_serviceHost.Open ();
			Console.ReadKey ();
			_serviceHost.Close ();
		}

        /// <summary>
        /// OSA Plugin Interface - called on start up to allow plugin to do any tasks it needs
        /// </summary>
        /// <param name="pluginName">The name of the plugin from the system</param>
        public override void RunInterface(string pluginName)
        {
            pName = pluginName;

            try
            {
                this.Log.Info("Starting Rest Interface");

                bool showHelp = bool.Parse(OSAEObjectPropertyManager.GetObjectPropertyValue(pName, "Show Help").Value);

                serviceHost = new WebServiceHost(typeof(OSAERest.api), new Uri("http://localhost:8732/api"));
                WebHttpBinding binding = new WebHttpBinding(WebHttpSecurityMode.None);
                binding.CrossDomainScriptAccessEnabled = true;

                var endpoint = serviceHost.AddServiceEndpoint(typeof(IRestService), binding, "");

                ServiceDebugBehavior sdb = serviceHost.Description.Behaviors.Find<ServiceDebugBehavior>();
                sdb.HttpHelpPageEnabled = false;

                if (showHelp)
                {
                    serviceHost.Description.Endpoints[0].Behaviors.Add(new WebHttpBehavior { HelpEnabled = true });
                }

                this.Log.Info("Starting Rest Interface");
                serviceHost.Open();
            }
            catch (Exception ex)
            {
                this.Log.Error("Error starting RESTful web service", ex);
            }
        }

 public QueryServiceHost(Uri address, object service)
 {
     host = new WebServiceHost(service);
     host.AddServiceEndpoint(typeof(IQueryService), new WebHttpBinding(), address);
     WebHttpBehavior behavior = new WebHttpBehavior();
     host.Description.Endpoints[0].Behaviors.Add(behavior);
 }

        static void Main(string[] args)
        {
            ItemCounter counter = new ItemCounter();

            using (WebServiceHost host = new WebServiceHost(new StreamingFeedService(counter), new Uri("http://localhost:8000/Service")))
            {
                WebHttpBinding binding = new WebHttpBinding();

                binding.TransferMode = TransferMode.StreamedResponse;
                host.AddServiceEndpoint(typeof(IStreamingFeedService), binding, "Feeds");

                host.Open();

                XmlReader reader = XmlReader.Create("http://localhost:8000/Service/Feeds/StreamedFeed");
                StreamedAtom10FeedFormatter formatter = new StreamedAtom10FeedFormatter(counter);

                Console.WriteLine("Reading stream from server");

                formatter.ReadFrom(reader);
                SyndicationFeed feed = formatter.Feed;

                foreach (SyndicationItem item in feed.Items)
                {
                    //This sample is implemented such that the server will generate an infinite stream of items;
                    //it only stops after the client reads 10 items
                    counter.Increment();
                }

                Console.WriteLine("CLIENT: read total of {0} items", counter.GetCount());
                Console.WriteLine("Press any key to terminate");
                Console.ReadLine();
            }
        }

        public void Start(string[] args)
        {
            HomeModule.Container = AppContext.Container;
            PackagesModule.Container = AppContext.Container;
            InstallationsModule.Container = AppContext.Container;
            LogModule.Container = AppContext.Container;
            ActionsModule.Container = AppContext.Container;
            ConfigurationModule.Container = AppContext.Container;

            Nancy.Json.JsonSettings.MaxJsonLength = 1024*1024*5; // 5mb max

            try
            {
                WebUiAddress = new Uri("http://localhost:9999/");
                _host = new WebServiceHost(new NancyWcfGenericService(), WebUiAddress);
                _host.AddServiceEndpoint(typeof (NancyWcfGenericService), new WebHttpBinding(), "");
                _host.Open();
            }
            catch (Exception ex)
            {
                _logger.Fatal(ex, "could not start listening");
            }

            _logger.Info("Hosting Web interface on: " + WebUiAddress);
        }

 static void Main(string[] args)
 {
     WebServiceHost host=new WebServiceHost(typeof(OperatingSystemService),new Uri("http://localhost:8013/RESTWebservice/"));
     host.Open();
     Console.ReadKey();
     host.Close();
 }

        // WebHttpBinding, REST based
        /**
         * If you do not add an endpoint, WebServiceHost automatically creates a default endpoint. WebServiceHost also adds WebHttpBehavior and disables the HTTP Help page and the Web Services Description Language (WSDL) GET functionality so the metadata endpoint does not interfere with the default HTTP endpoint.
         * Adding a non-SOAP endpoint with a URL of "" causes unexpected behavior when an attempt is made to call an operation on the endpoint. The reason for this is the listen URI of the endpoint is the same as the URI for the help page (the page that is displayed when you browse to the base address of a WCF service).
         *
         *
         * */
        private static void StartWebHTTPService()
        {
            string strAdr = "http://localhost" + "/MathService";
            WebServiceHost webServiceHost;
            try
            {
                Uri adrbase = new Uri(strAdr);

                webServiceHost = new WebServiceHost(typeof(MathService), adrbase);

                //To disable help page to avoid interference with normal http get

                ServiceDebugBehavior sdb = webServiceHost.Description.Behaviors.Find<ServiceDebugBehavior>();
                sdb.HttpHelpPageEnabled = false;

                WebHttpBinding webHttpBinding = new WebHttpBinding();
                webServiceHost.AddServiceEndpoint(typeof(IMathService), webHttpBinding, "");
                webServiceHost.Open();
                Console.WriteLine("\n\nService on WebHttpBinding is Running as >> " + strAdr);

            }
            catch (Exception eX)
            {
                webServiceHost = null;
                Console.WriteLine("Service can not be started as >> [" +
                  strAdr + "] \n\nError Message [" + eX.Message + "]");
            }
        }

 public void StartWebService()
 {
     //BasicConfigurator.Configure( new PatternLayout("%d [%t] %-5p %c %m%n"), @".\test.txt");
     RestDemoServices DemoServices = new RestDemoServices();
     WebServiceHost _serviceHost = new WebServiceHost(DemoServices, new Uri(URL));
     _serviceHost.Open();
 }

        private static void Start(string[] args)
        {
            WebServicesImplementation PureCloudServices = new WebServicesImplementation();
            WebServiceHost _serviceHost = new WebServiceHost(PureCloudServices, new Uri(PureCloudServices.URL));

            _serviceHost.Open();
        }

        public void GetTodosFiltered()
        {
            using (var server = new WebServiceHost(new TodoService(), new Uri(_hostAddress)))
            using (var client = new WebChannelFactory<ITodoApi>(new WebHttpBinding(), new Uri(_hostAddress)))
            {
                server.Open();
                client.Open();
                var channel = client.CreateChannel();

                using (new OperationContextScope((IContextChannel)channel))
                {
                    var todos = channel.GetTodosFiltered(true);
                    ValidateHttpStatusResponse(HttpStatusCode.OK);

                    Assert.AreEqual(1, todos.Todo.Length);
                }

                using (new OperationContextScope((IContextChannel)channel))
                {
                    var todos = channel.GetTodosFiltered(false);
                    ValidateHttpStatusResponse(HttpStatusCode.OK);

                    Assert.AreEqual(2, todos.Todo.Length);
                }
            }
        }