public static void Run() { // Open post as non-admin: // http://msdn.microsoft.com/en-us/library/ms733768.aspx // netsh http add urlacl url=http://+:9999/ user='******' var host = new ServiceHost (typeof (Server)); AddMexEndpoint (host); host.AddServiceEndpoint ( typeof (IMyService), new BasicHttpBinding (), new Uri ("http://provcon-faust:9999/service/")); host.AddServiceEndpoint ( typeof (IMyService), new BasicHttpBinding (BasicHttpSecurityMode.Transport), new Uri ("https://provcon-faust:9998/secureservice/")); AddNetTcp (host); AddNetTcp2 (host); host.Open (); foreach (var endpoint in host.Description.Endpoints) Console.WriteLine (endpoint.Address); Console.WriteLine ("Service running."); Console.ReadLine (); host.Close (); }
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); } }
static void Main(string[] args) { IPHostEntry entry = Dns.GetHostEntry(""); string addr = "localhost"; for (int i = 0; i < entry.AddressList.Length; i++) { if (entry.AddressList[i].AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { addr = entry.AddressList[i].ToString(); break; } } Uri baseAddress = new Uri("http://" + addr + ":8084/319D0A4D-2253-47DC-AC4A-C1951FF6667D"); ServiceHost serviceHost = new ServiceHost(typeof(ServiceHelloWCF), baseAddress); try { ServiceEndpoint wsEndpoint = serviceHost.AddServiceEndpoint(typeof(IServiceHelloWCF), new WSHttpBinding(SecurityMode.None), string.Empty); EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); // Add the discovery behavior to the endpoint. wsEndpoint.Behaviors.Add(endpointDiscoveryBehavior); // Make the service discoverable over UDP multicast serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscovery11)); ServiceMetadataBehavior smb = new ServiceMetadataBehavior(); smb.HttpGetEnabled = true; smb.HttpGetUrl = baseAddress; serviceHost.Description.Behaviors.Add(smb); serviceHost.Open(); Console.WriteLine("Hello World WCF Service started at {0}", baseAddress); Console.WriteLine(); Console.WriteLine("Press <ENTER> to terminate the service."); Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } catch (CommunicationException e) { Console.WriteLine(e.Message); } catch (TimeoutException e) { Console.WriteLine(e.Message); } if (serviceHost.State != CommunicationState.Closed) { Console.WriteLine("Aborting service..."); serviceHost.Abort(); } }
static void Main(string[] args) { // Create binding for the service endpoint. CustomBinding amqpBinding = new CustomBinding(); amqpBinding.Elements.Add(new BinaryMessageEncodingBindingElement()); amqpBinding.Elements.Add(new AmqpTransportBindingElement()); // Create ServiceHost. ServiceHost serviceHost = new ServiceHost(typeof(HelloService), new Uri[] { new Uri("http://localhost:8080/HelloService2") }); // Add behavior for our MEX endpoint. ServiceMetadataBehavior mexBehavior = new ServiceMetadataBehavior(); mexBehavior.HttpGetEnabled = true; serviceHost.Description.Behaviors.Add(mexBehavior); // Add MEX endpoint. serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), new BasicHttpBinding(), "MEX"); // Add AMQP endpoint. Uri amqpUri = new Uri("amqp:news"); serviceHost.AddServiceEndpoint(typeof(IHelloService), amqpBinding, amqpUri.ToString()); serviceHost.Open(); Console.WriteLine(); Console.WriteLine("The consumer is now listening on the queue \"news\"."); Console.WriteLine("Press <ENTER> to terminate service."); Console.WriteLine(); Console.ReadLine(); if (serviceHost.State != CommunicationState.Faulted) { serviceHost.Close(); } }
protected override void OnStart(string[] args) { var baseAddresses = new Uri[] { new Uri(Properties.Settings.Default.ServiceHttpUri), new Uri(Properties.Settings.Default.ServiceNamedPipeUri), }; _serviceHost = new ServiceHost(_singletonService, baseAddresses); _serviceHost.AddServiceEndpoint(typeof(ILocationService), new BasicHttpBinding(), "Location"); _serviceHost.AddServiceEndpoint(typeof(ILocationService), new NetNamedPipeBinding(), "Location"); var smb = new ServiceMetadataBehavior(); smb.HttpGetEnabled = true; smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15; _serviceHost.Description.Behaviors.Add(smb); _serviceHost.Description.Behaviors.Find<ServiceDebugBehavior>().IncludeExceptionDetailInFaults = true; _serviceHost.Open(); }
static void Main(string[] args) { Console.WriteLine("Server Started and Listening....."); //Host service or Service Instance wcf.ServiceHost _wcfServiceHost = new wcf.ServiceHost(typeof(CalculatorLib.Calculator)); //Add Endpoint System.Type _contract = typeof(CalculatorServiceContractLib.ICalculate); //Bidning wcf.NetNamedPipeBinding _localMachineBidning = new wcf.NetNamedPipeBinding(); //Address string address = "net.pipe://localhost/onmachinecchannel"; //wcf.Description.ServiceEndpoint _localMachineCommunicationChannel = // new wcf.Description.ServiceEndpoint( // new wcf.Description.ContractDescription(_contract.FullName), // _localMachineBidning, // new wcf.EndpointAddress(address) // ); //_wcfServiceHost.AddServiceEndpoint(_localMachineCommunicationChannel); _wcfServiceHost.AddServiceEndpoint(_contract, _localMachineBidning, address); //LAN Clients _wcfServiceHost.AddServiceEndpoint(_contract, new NetTcpBinding(), "net.tcp://localhost:5000/lanep"); //WAN _wcfServiceHost.AddServiceEndpoint(_contract, new BasicHttpBinding(), "http://localhost:8001/wanep"); _wcfServiceHost.Open();// ServiceHost availability for Client Requests Console.ReadKey(); }
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(); }
private static ServiceHost HostDiscoveryEndpoint(string hostName) { // Create a new ServiceHost with a singleton ChatDiscovery Proxy ServiceHost myProxyHost = new ServiceHost(new ChatDiscoveryProxy()); string proxyAddress = "net.tcp://" + hostName + ":8001/discoveryproxy"; // Create the discovery endpoint DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint( new NetTcpBinding(), new EndpointAddress(proxyAddress)); discoveryEndpoint.IsSystemEndpoint = false; // Add UDP Annoucement endpoint myProxyHost.AddServiceEndpoint(new UdpAnnouncementEndpoint()); // Add the discovery endpoint myProxyHost.AddServiceEndpoint(discoveryEndpoint); myProxyHost.Open(); Console.WriteLine("Discovery Proxy {0}", proxyAddress); return myProxyHost; }
static void ServiceFromCode() { Console.Out.WriteLine("Testing Udp From Code."); Binding datagramBinding = new CustomBinding(new BinaryMessageEncodingBindingElement(), new UdpTransportBindingElement()); // using the 2-way calculator method requires a session since UDP is not inherently request-response SampleProfileUdpBinding calculatorBinding = new SampleProfileUdpBinding(true); calculatorBinding.ClientBaseAddress = new Uri("soap.udp://localhost:8003/"); Uri calculatorAddress = new Uri("soap.udp://localhost:8001/"); Uri datagramAddress = new Uri("soap.udp://localhost:8002/datagram"); // we need an http base address so that svcutil can access our metadata ServiceHost service = new ServiceHost(typeof(CalculatorService), new Uri("http://localhost:8000/udpsample/")); ServiceMetadataBehavior metadataBehavior = new ServiceMetadataBehavior(); metadataBehavior.HttpGetEnabled = true; service.Description.Behaviors.Add(metadataBehavior); service.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex"); service.AddServiceEndpoint(typeof(ICalculatorContract), calculatorBinding, calculatorAddress); service.AddServiceEndpoint(typeof(IDatagramContract), datagramBinding, datagramAddress); service.Open(); Console.WriteLine("Service is started from code..."); Console.WriteLine("Press <ENTER> to terminate the service and start service from config..."); Console.ReadLine(); service.Close(); }
public void StartService() { Uri baseAddress = new Uri("http://localhost:8001/MarkManagementService"); Type contractType = typeof(IService); Type instanceType = typeof(OperationService); host = new ServiceHost(instanceType, baseAddress); // Create basicHttpBinding endpoint at http://localhost:8001/OperationService string relativeAddress = "OperationService"; host.AddServiceEndpoint(contractType, new BasicHttpBinding(), relativeAddress); NetTcpBinding A = new NetTcpBinding(SecurityMode.Transport); host.AddServiceEndpoint(contractType, new NetTcpBinding(), "net.tcp://localhost:9000/MarkManagementService"); host.AddServiceEndpoint(contractType, A, "net.tcp://localhost:9001/MarkManagementService"); // Add behavior for our MEX endpoint //Add Mex endpoint can dung de khi client discovery thay duoc service ServiceMetadataBehavior behavior = new ServiceMetadataBehavior(); behavior.HttpGetEnabled = true; host.Description.Behaviors.Add(behavior); // Add MEX endpoint at http://localhost:8000/MEX/ host.AddServiceEndpoint(typeof(IMetadataExchange), new BasicHttpBinding(), "MEX"); host.Open(); lbl_mess.Text = "Service is starting"; lbl_mess.ForeColor = Color.Green; }
static void Main(string[] args) { var baseAddress = new Uri(string.Format("http://localhost:11001/mixedservice/{0}/", Guid.NewGuid().ToString())); using (var host = new ServiceHost(typeof(MixedService), baseAddress)) { host.Opened += (sender, e) => { host.Description.Endpoints.All((ep) => { Console.WriteLine(ep.Contract.Name + ": " + ep.ListenUri); return true; }); }; var serviceMetadataBehavior = new ServiceMetadataBehavior(); serviceMetadataBehavior.HttpGetEnabled = true; serviceMetadataBehavior.MetadataExporter.PolicyVersion = PolicyVersion.Policy15; host.Description.Behaviors.Add(serviceMetadataBehavior); host.AddServiceEndpoint(typeof(IStringService), new BasicHttpBinding(), "string"); host.AddServiceEndpoint(typeof(ICalculateService), new BasicHttpBinding(), "calculate"); host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName, MetadataExchangeBindings.CreateMexHttpBinding(), "mex"); host.Open(); Console.WriteLine("Press any key to exit."); Console.ReadKey(); } }
public Form1() { InitializeComponent(); IntPtr dummyHandle = Handle; lvMission.DoubleBuffer(true); lvNDock.DoubleBuffer(true); lvMission.LoadColumnWithOrder(Properties.Settings.Default.MissionColumnWidth); lvNDock.LoadColumnWithOrder(Properties.Settings.Default.DockColumnWidth); var host = new RemoteHost(this); servHost = new ServiceHost(host); if (Properties.Settings.Default.NetTcp) { var bind = new NetTcpBinding(SecurityMode.None); bind.Security.Message.ClientCredentialType = MessageCredentialType.UserName; servHost.AddServiceEndpoint(typeof(KCB.RPC.IUpdateNotification), bind, new Uri("net.tcp://localhost/kcb-update-channel")); servHost.Credentials.UserNameAuthentication.CustomUserNamePasswordValidator = new HogeFugaValidator(); servHost.Credentials.UserNameAuthentication.UserNamePasswordValidationMode = System.ServiceModel.Security.UserNamePasswordValidationMode.Custom; Debug.WriteLine("Protocol:Net.Tcp"); bTcpMode = true; } else { servHost.AddServiceEndpoint(typeof(KCB.RPC.IUpdateNotification), new NetNamedPipeBinding(), new Uri("net.pipe://localhost/kcb-update-channel")); Debug.WriteLine("Protocol:Net.Pipe"); } servHost.Open(); //起動し終えたのでシグナル状態へ Program._mutex.ReleaseMutex(); }
/// <summary> /// Initializes the host. /// </summary> /// <param name="callback">Callback.</param> public void InitializeHost(IntPtr callback) { if (callback != IntPtr.Zero) { ExternalCallback = GCHandle.Alloc(Marshal.GetDelegateForFunctionPointer <Utilities.QtExternalCode> (callback)); DaemonOperation.QtMessenger = new Action <string> (ShowMessage); } ShowMessage("Creating binding..."); var binding = new BasicHttpBinding(); binding.Security.Mode = BasicHttpSecurityMode.None; ShowMessage("Allocating endpoint addresses..."); var address = new Uri("http://localhost:8888/monodaemon"); var addressMex = new Uri("http://localhost:8888/monodaemon/mex"); ShowMessage("Creating host..."); m_host = new System.ServiceModel.ServiceHost(typeof(DaemonOperation), new Uri[] { new Uri("http://localhost:8888/monodaemon") }); ShowMessage("Adding behaviors..."); m_host.Description.Behaviors.Remove <System.ServiceModel.Description.ServiceMetadataBehavior> (); m_host.Description.Behaviors.Add(new System.ServiceModel.Description.ServiceMetadataBehavior { HttpGetEnabled = true, HttpsGetEnabled = false }); ShowMessage("Adding endpoints..."); m_host.AddServiceEndpoint(typeof(IDaemonOperation), binding, address); m_host.AddServiceEndpoint(System.ServiceModel.Description.ServiceMetadataBehavior.MexContractName, System.ServiceModel.Description.MetadataExchangeBindings.CreateMexHttpBinding(), addressMex); ShowMessage("Starting host..."); m_host.Open(); }
static void Main() { // только не null, ибо возникнет исключение //var baseAddress = new Uri("http://localhost:8002/MyService"); var host = new ServiceHost(typeof(MyContractClient));//, baseAddress); host.Open(); //var otherBaseAddress = new Uri("http://localhost:8001/"); var otherHost = new ServiceHost(typeof(MyOtherContractClient));//, otherBaseAddress); var wsBinding = new BasicHttpBinding(); var tcpBinding = new NetTcpBinding(); otherHost.AddServiceEndpoint(typeof(IMyOtherContract), wsBinding, "http://localhost:8001/MyOtherService"); otherHost.AddServiceEndpoint(typeof(IMyOtherContract), tcpBinding, "net.tcp://localhost:8003/MyOtherService"); //AddHttpGetMetadata(otherHost); AddMexEndpointMetadata(otherHost); otherHost.Open(); // you can access http://localhost:8002/MyService Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Host()); otherHost.Close(); host.Close(); // you can not access http://localhost:8002/MyService }
static void Main(string[] args) { Uri tcpBaseAddress = new Uri("net.tcp://localhost:6789/"); ServiceHost sh = new ServiceHost(typeof(TransactionService), new Uri[] { tcpBaseAddress }); var netTcpBinding = new NetTcpBinding(); netTcpBinding.TransactionFlow = true; ServiceEndpoint se = sh.AddServiceEndpoint(typeof(ITransactionService), netTcpBinding, tcpBaseAddress); ServiceMetadataBehavior smb = sh.Description.Behaviors.Find<ServiceMetadataBehavior>(); if (smb == null) smb = new ServiceMetadataBehavior(); sh.Description.Behaviors.Add(smb); ServiceEndpoint httpSeMex = sh.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "net.tcp://localhost:6789/mex"); sh.Open(); Console.WriteLine("Started..."); foreach (var item in sh.Description.Endpoints) { Console.WriteLine("Address: " + item.Address.ToString()); Console.WriteLine("Binding: " + item.Binding.Name.ToString()); Console.WriteLine("Contract: " + item.Contract.Name.ToString()); Console.WriteLine("------------------"); } Console.ReadLine(); sh.Close(); Console.WriteLine("Closed..."); }
static void Main(string[] args) { // string address = "http://localhost:23456/TrustedServer/"; if(args==null || args.Count() <1 ) { Usage(); return; } string address = args[0]; BasicHttpBinding binding = new BasicHttpBinding(); ServiceHost host = new ServiceHost(typeof(MetaDataServer), new Uri(address)); host.AddServiceEndpoint(typeof(IMetaDataService), binding, address); ServiceMetadataBehavior smb = new ServiceMetadataBehavior(); smb.HttpGetEnabled = true; host.Description.Behaviors.Add(smb); host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName, MetadataExchangeBindings.CreateMexHttpBinding(), "mex"); // host.AddDefaultEndpoints(); MetaDataServer.initializeFromFile(); host.Open(); Console.WriteLine("Host is {0}. Press enter to close.", host.State); Console.ReadLine(); MetaDataServer.writeToFile(); host.Close(); }
private ServiceHost BuildHost( IWcfServiceConfiguration configuration ) { var serviceUri = configuration.Address; var host = new ServiceHost( configuration.ServiceType, new Uri( ServerConfiguration.BaseAddress ) ); host.AddServiceEndpoint( configuration.ContractType, configuration.Binding, serviceUri ); if ( configuration.EnableHttpMetadataExchange ) { var mexUriString = "{0}/{1}".AsFormat( configuration.MetadataExchangeUri ?? ServerConfiguration.BaseAddress, configuration.Address ); host.Description.Behaviors.Add( new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = new Uri( mexUriString ) } ); host.AddServiceEndpoint( typeof( IMetadataExchange ), configuration.Binding, "mex" ); } host.CloseTimeout = TimeSpan.FromMilliseconds( configuration.Timeout ); return host; }
static void Main(string[] args) { string baseAddress = "http://" + Environment.MachineName + ":8000/Service"; ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress)); host.AddServiceEndpoint(typeof(ITestService), new BasicHttpBinding(), "soap"); WebHttpBinding webBinding = new WebHttpBinding(); webBinding.ContentTypeMapper = new MyRawMapper(); host.AddServiceEndpoint(typeof(ITestService), webBinding, "json").Behaviors.Add(new NewtonsoftJsonBehavior()); Console.WriteLine("Opening the host"); host.Open(); ChannelFactory<ITestService> factory = new ChannelFactory<ITestService>(new BasicHttpBinding(), new EndpointAddress(baseAddress + "/soap")); ITestService proxy = factory.CreateChannel(); Console.WriteLine(proxy.GetPerson()); SendRequest(baseAddress + "/json/GetPerson", "GET", null, null); SendRequest(baseAddress + "/json/EchoPet", "POST", "application/json", "{\"Name\":\"Fido\",\"Color\":\"Black and white\",\"Markings\":\"None\",\"Id\":1}"); SendRequest(baseAddress + "/json/Add", "POST", "application/json", "{\"x\":111,\"z\":null,\"w\":[1,2],\"v\":{\"a\":1},\"y\":222}"); Console.WriteLine("Now using the client formatter"); ChannelFactory<ITestService> newFactory = new ChannelFactory<ITestService>(webBinding, new EndpointAddress(baseAddress + "/json")); newFactory.Endpoint.Behaviors.Add(new NewtonsoftJsonBehavior()); ITestService newProxy = newFactory.CreateChannel(); Console.WriteLine(newProxy.Add(444, 555)); Console.WriteLine(newProxy.EchoPet(new Pet { Color = "gold", Id = 2, Markings = "Collie", Name = "Lassie" })); Console.WriteLine(newProxy.GetPerson()); Console.WriteLine("Press ENTER to close"); Console.ReadLine(); host.Close(); Console.WriteLine("Host closed"); }
static void Main(string[] args) { //ServiceHost myHost = new ServiceHost(typeof(WCFService)); ServiceHost myHost = new ServiceHost(typeof(WCFService), new Uri("http://localhost:9003/AI3"), new Uri("net.tcp://localhost:9004/AI4")); myHost.AddDefaultEndpoints(); myHost.AddServiceEndpoint(typeof(IWCFService), new BasicHttpBinding(), "http://localhost:9001/AI"); myHost.AddServiceEndpoint(typeof(IWCFService), new NetTcpBinding(), "net.tcp://localhost:9002/"); ServiceMetadataBehavior behavior = new ServiceMetadataBehavior(); behavior.HttpGetUrl = new Uri("http://localhost:8090/WCFService"); behavior.HttpGetEnabled = true; myHost.Description.Behaviors.Add(behavior); try { myHost.Open(); Console.WriteLine("Service is worked ! Status : " + myHost.State); foreach (ServiceEndpoint ep in myHost.Description.Endpoints) { Console.WriteLine("A : {0} - B : {1} - C : {2}", ep.Address, ep.Binding.Name, ep.Contract.Name); } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadLine(); }
public static void Open(string tibcoEndpointUri) { Uri uri; if (!Uri.TryCreate(tibcoEndpointUri, UriKind.Absolute, out uri)) { uri = new Uri("http://0.0.0.0:50701"); } _host = new ServiceHost(typeof(OscarServices), uri); var smb = new ServiceMetadataBehavior { HttpGetEnabled = true, }; smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15; _host.Description.Behaviors.Add(smb); var sdb = _host.Description.Behaviors.Find<ServiceDebugBehavior>(); if (sdb == null) { sdb = new ServiceDebugBehavior(); _host.Description.Behaviors.Add(sdb); } sdb.IncludeExceptionDetailInFaults = false; sdb.HttpHelpPageEnabled = false; _host.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName, MetadataExchangeBindings.CreateMexHttpBinding(), "mex"); var bhb = new BasicHttpBinding() { Namespace = "urn:Mpcr.Services.Oscar" }; bhb.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly; bhb.Security.Transport.ClientCredentialType = HttpClientCredentialType.Ntlm; _host.AddServiceEndpoint(typeof(IOscarServices), bhb, ""); _host.Authorization.ServiceAuthorizationManager = new TibcoAuthManager(); _host.Open(); }
public static void Main() { Uri baseAddress = new Uri("http://localhost:8000/" + Guid.NewGuid().ToString()); ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress); try { // Add an endpoint to the service ServiceEndpoint discoverableCalculatorEndpoint = serviceHost.AddServiceEndpoint( typeof(ICalculatorService), new WSHttpBinding(), "/DiscoverableEndpoint"); // Add a Scope to the endpoint EndpointDiscoveryBehavior discoverableEndpointBehavior = new EndpointDiscoveryBehavior(); discoverableEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us")); discoverableCalculatorEndpoint.Behaviors.Add(discoverableEndpointBehavior); // Add an endpoint to the service ServiceEndpoint nonDiscoverableCalculatorEndpoint = serviceHost.AddServiceEndpoint (typeof(ICalculatorService), new WSHttpBinding(), "/NonDiscoverableEndpoint"); // Disable discoverability of the endpoint EndpointDiscoveryBehavior nonDiscoverableEndpointBehavior = new EndpointDiscoveryBehavior(); nonDiscoverableEndpointBehavior.Scopes.Add(new Uri("ldap:///ou=engineering,o=exampleorg,c=us")); nonDiscoverableEndpointBehavior.Enabled = false; nonDiscoverableCalculatorEndpoint.Behaviors.Add(nonDiscoverableEndpointBehavior); // Make the service discoverable over UDP multicast serviceHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); serviceHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); serviceHost.Open(); Console.WriteLine("Calculator Service started at {0}", baseAddress); Console.WriteLine(); Console.WriteLine("Press <ENTER> to terminate the service."); Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } catch (CommunicationException e) { Console.WriteLine(e.Message); } catch (TimeoutException e) { Console.WriteLine(e.Message); } if (serviceHost.State != CommunicationState.Closed) { Console.WriteLine("Aborting the service..."); serviceHost.Abort(); } }
static void Main(string[] args) { ServiceHost host = new ServiceHost(typeof(CustomerService), new Uri[] { new Uri("net.tcp://localhost:8383/CustomerMgmService/") } ); ServiceMetadataBehavior mexBehavior = new ServiceMetadataBehavior(); host.AddServiceEndpoint(typeof(ICustomerMgmService), new NetTcpBinding(SecurityMode.Transport), "CMS"); #if DEBUG //don't want to deploy metadata host.Description.Behaviors.Add(mexBehavior); host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "mex"); #endif foreach (var ba in host.BaseAddresses) { Console.WriteLine("BaseAddress: \n" + ba); } foreach (var ep in host.Description.Endpoints) { Console.WriteLine("\n\nEndpoint: \n- {0}\n- {1}\n- {2}", ep.Address.Uri, ep.Name, ep.Binding.Name); } host.Open(); Console.WriteLine("\n\nCustomerMgmService is open"); Console.ReadKey(); host.Close(); }
/// <summary> /// Hosting a service using managed code without any configuraiton information. /// Please note that the related configuration data should be removed before calling the method. /// </summary> private static void HostCalculatorServiceViaCode() { var httpBaseAddress = new Uri("http://localhost:8888/generalCalculator"); var tcpBaseAddress = new Uri("net.tcp://localhost:9999/generalCalculator"); using (var calculatorSerivceHost = new ServiceHost(typeof(GeneralCalculatorService), httpBaseAddress, tcpBaseAddress)) { var httpBinding = new BasicHttpBinding(); var tcpBinding = new NetTcpBinding(); calculatorSerivceHost.AddServiceEndpoint(typeof(IGeneralCalculator), httpBinding, string.Empty); calculatorSerivceHost.AddServiceEndpoint(typeof(IGeneralCalculator), tcpBinding, string.Empty); var behavior = calculatorSerivceHost.Description.Behaviors.Find<ServiceMetadataBehavior>(); { if (behavior == null) { behavior = new ServiceMetadataBehavior(); behavior.HttpGetEnabled = true; calculatorSerivceHost.Description.Behaviors.Add(behavior); } else { behavior.HttpGetEnabled = true; } } calculatorSerivceHost.Opened += delegate { Console.WriteLine("Calculator Service has begun to listen ... ..."); }; calculatorSerivceHost.Open(); Console.Read(); } }
static void Main(string[] args) { Uri baseAddress = new Uri("http://localhost:8000/CalculatorService/"); ServiceHost selfHost = new ServiceHost(typeof(CalculatorService), baseAddress); try { selfHost.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(), "CalculatorService"); //ServiceMetadataBehavior smb = new ServiceMetadataBehavior(); //smb.HttpGetEnabled = true; //selfHost.Description.Behaviors.Add(smb); selfHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); selfHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); selfHost.Open(); Console.WriteLine("The service is ready."); Console.WriteLine("Press <ENTER> to terminate service."); Console.WriteLine(); Console.ReadLine(); selfHost.Close(); } catch (CommunicationException ce) { Console.WriteLine("An exception occurred: {0}", ce.Message); selfHost.Abort(); } }
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 StartStopService() { var baseUri = new Uri("http://localhost:8080/MyWebPage.WCF_Lab2"); var selfServiceHost = new ServiceHost(typeof(MyWebPageEntryPoint), baseUri); using (selfServiceHost) { selfServiceHost.AddServiceEndpoint(typeof(ICalculateAge), new WSHttpBinding(), "CalculateAgeService"); selfServiceHost.AddServiceEndpoint(typeof(ICalculateBmi), new WSHttpBinding(), "CalculateBmiService"); selfServiceHost.AddServiceEndpoint(typeof(ICalculateEvenBirthday), new WSHttpBinding(), "CalculateEvenBirthdayService"); selfServiceHost.AddServiceEndpoint(typeof(ICalculateCalories), new WSHttpBinding(), "CalculateCaloriesBurned"); var smBehavior = new ServiceMetadataBehavior { HttpGetEnabled = true }; selfServiceHost.Description.Behaviors.Add(smBehavior); selfServiceHost.Open(); Console.WriteLine($"Service opened: {DateTime.Now} at: {baseUri}"); Console.WriteLine("Press enter to shut down selfservice."); Console.ReadKey(); } }
static void ServicoProtocoloNETTCP() { //Configuro a URL que vou SUBIR(DISPONIBILIZAR) O SERVIÇO WCF Uri EnderecoServico = new Uri("net.tcp://localhost:8181/Demonstracao2/MeuServico"); //Classe serve para (HOSPEDAR, ARMAZENAR) O SERVIÇO WCF //Informo o nome do SERVIÇO (Servicos.Contato) //Informo o endereço que vou SUBIR O SERVIÇO ServiceHost Host = new ServiceHost(typeof(Servicos.Contato), EnderecoServico); //Habilitei o WSDL para os clientes //WSDL = MEX no protocolo NET.TCP Host.Description.Behaviors.Add(new ServiceMetadataBehavior()); //Configuração do WSDL(MEX) Host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "MEX/"); //Adicionei o ENDPOINT (Contrato que vai ser trafegado para o cliente) //Adicionei o ENDPOINT (Tipo de Binding (PROTOCOLO)) //Adicionei o ENDPOINT (Nome do SERVIÇO) Host.AddServiceEndpoint(typeof(Servicos.IContato), new NetTcpBinding(), "Servicos.Contato"); //Liguei o SERVIÇO Host.Open(); }
static void Main(string[] args) { ServiceHost sh = new ServiceHost(typeof(StringReverser)); sh.AddServiceEndpoint( typeof(IStringReverser), new NetTcpBinding(), "net.tcp://localhost:9358/reverse"); sh.AddServiceEndpoint( typeof(IStringReverser), new NetTcpRelayBinding(), ServiceBusEnvironment.CreateServiceUri("sb", "ckdemo", "solver")) .Behaviors.Add(new TransportClientEndpointBehavior { TokenProvider = TokenProvider.CreateSharedSecretTokenProvider( ConfigurationManager.AppSettings["issuerName"], ConfigurationManager.AppSettings["issuerSecret"]) }); sh.Open(); Console.WriteLine("Press ENTER to close"); Console.ReadLine(); sh.Close(); }
static void Main(string[] args) { Uri httpBaseAddress = new Uri("http://localhost:6789/"); ServiceHost sh = new ServiceHost(typeof (MEP), new Uri[] {httpBaseAddress}); //ServiceEndpoint se = sh.AddServiceEndpoint(typeof (IMEP), new BasicHttpBinding(), httpBaseAddress); ServiceEndpoint se = sh.AddServiceEndpoint(typeof(IMEP), new WSDualHttpBinding(), httpBaseAddress); ServiceMetadataBehavior smb = sh.Description.Behaviors.Find<ServiceMetadataBehavior>(); if(smb == null) smb = new ServiceMetadataBehavior(); sh.Description.Behaviors.Add(smb); ServiceEndpoint httpSeMex = sh.AddServiceEndpoint(typeof (IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "http://localhost:6789/mex"); sh.Open(); Console.WriteLine("Started..."); foreach (var item in sh.Description.Endpoints) { Console.WriteLine("Address: " + item.Address.ToString()); Console.WriteLine("Binding: " + item.Binding.Name.ToString()); Console.WriteLine("Contract: " + item.Contract.Name.ToString()); Console.WriteLine("------------------"); } Console.ReadLine(); sh.Close(); Console.WriteLine("Closed..."); }
public ServiceHost CreateServiceHost(ClusterConfiguration clusterConfiguration) { var managerNode = new ManagerNode(clusterConfiguration); managerNode.Start(); var serviceHost = new ServiceHost(managerNode, new[] { new Uri(string.Format("http://localhost:{0}/brightstarcluster", Configuration.HttpPort)), new Uri(string.Format("net.tcp://localhost:{0}/brightstarcluster", Configuration.TcpPort)), new Uri(string.Format("net.pipe://localhost/{0}", Configuration.NamedPipeName)) }); var basicHttpBinding = new BasicHttpContextBinding { TransferMode = TransferMode.StreamedResponse, MaxReceivedMessageSize = int.MaxValue, SendTimeout = TimeSpan.FromMinutes(30), ReaderQuotas = XmlDictionaryReaderQuotas.Max, Namespace = "http://www.networkedplanet.com/schemas/brightstar" }; var netTcpContextBinding = new NetTcpContextBinding { TransferMode = TransferMode.StreamedResponse, MaxReceivedMessageSize = int.MaxValue, SendTimeout = TimeSpan.FromMinutes(30), ReaderQuotas = XmlDictionaryReaderQuotas.Max, Namespace = "http://www.networkedplanet.com/schemas/brightstar" }; var netNamedPipeBinding = new NetNamedPipeBinding { TransferMode = TransferMode.StreamedResponse, MaxReceivedMessageSize = int.MaxValue, SendTimeout = TimeSpan.FromMinutes(30), ReaderQuotas = XmlDictionaryReaderQuotas.Max, Namespace = "http://www.networkedplanet.com/schemas/brightstar" }; serviceHost.AddServiceEndpoint(typeof(IBrightstarClusterManagerService), basicHttpBinding, ""); serviceHost.AddServiceEndpoint(typeof(IBrightstarClusterManagerService), netTcpContextBinding, ""); serviceHost.AddServiceEndpoint(typeof(IBrightstarClusterManagerService), netNamedPipeBinding, ""); var throttlingBehavior = new ServiceThrottlingBehavior { MaxConcurrentCalls = int.MaxValue }; serviceHost.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true }); serviceHost.Description.Behaviors.Add(throttlingBehavior); serviceHost.Closed += StopNode; return serviceHost; }
public ServiceHost createLobby(string ip, Lobby lobby) { string uri = TCP_CONN_STR + ip; ServiceHost host = new ServiceHost( lobby, new Uri[]{ new Uri(uri) }); host.AddServiceEndpoint(typeof(ILobby), new NetTcpBinding(SecurityMode.None), LOBBY_NAME); ServiceHost discoveryHost = new ServiceHost( new DiscoveryTest(), new Uri[]{ new Uri(uri + "/Discovery") }); discoveryHost.Description.Behaviors.Add(new ServiceDiscoveryBehavior()); discoveryHost.AddServiceEndpoint(new UdpDiscoveryEndpoint()); discoveryHost.AddServiceEndpoint(typeof(IDiscoveryTest), new NetTcpBinding(SecurityMode.None), ""); discoveryHost.Open(); return host; }
/// <summary> /// Starts listening at the specified port. /// </summary> public void Start() { lock (m_lock) { UriBuilder root = new UriBuilder(m_uri); string path = root.Path; root.Path = String.Empty; WebHttpBinding binding = null; if (root.Scheme == Utils.UriSchemeHttps) { binding = new WebHttpBinding(WebHttpSecurityMode.Transport); } else { binding = new WebHttpBinding(); } Service service = new Service(); service.Listener = this; m_host = new System.ServiceModel.ServiceHost(service, m_uri); m_host.AddServiceEndpoint(typeof(ICrossDomainPolicy), binding, root.Uri).Behaviors.Add(new WebHttpBehavior()); m_host.AddServiceEndpoint(typeof(IInvokeService), binding, "").Behaviors.Add(new WebHttpBehavior()); m_host.Open(); } }
static void Main(string[] args) { var logger = new Logger(typeof(WordCounter)); var svcHost = new ServiceHost(typeof(WordCounter), new Uri("http://localhost:50000/WordCount")); var smb = svcHost.Description.Behaviors.Find<ServiceMetadataBehavior>(); // If not, add one if (smb == null) smb = new ServiceMetadataBehavior(); smb.HttpGetEnabled = true; smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15; svcHost.Description.Behaviors.Add(smb); // Add MEX endpoint svcHost.AddServiceEndpoint( ServiceMetadataBehavior.MexContractName, MetadataExchangeBindings.CreateMexHttpBinding(), "mex" ); var ep = svcHost.AddServiceEndpoint(typeof(IWordCount), new BasicHttpBinding(), ""); svcHost.Open(); Console.WriteLine("Service is running on: "); foreach (var endPoint in svcHost.Description.Endpoints) { Console.WriteLine(endPoint.Address); } Console.WriteLine("Press enter to quit..."); Console.ReadLine(); svcHost.Close(); }
public void Start() { _serviceCore = new TradingServerWCFService(); _serviceHost = new System.ServiceModel.ServiceHost(_serviceCore, _uris); _serviceHost.AddServiceEndpoint(typeof(IWCFConnection), _netTcpBinding, _uris[0]); _serviceHost.Description.Behaviors.Add(new ServiceMetadataBehavior()); _serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexHttpBinding(), "mex"); _serviceHost.Open(); }
static void Main(string[] args) { Console.WriteLine("Server Started and Listening....."); #region CalculatorService Registration //Host service or Service Instance wcf.ServiceHost _wcfServiceHost = new wcf.ServiceHost(typeof(CalculatorLib.Calculator)); //Add Endpoint System.Type _contract = typeof(CalculatorServiceContractLib.ICalculate); //Bidning wcf.NetNamedPipeBinding _localMachineBidning = new wcf.NetNamedPipeBinding(); //Address string address = "net.pipe://localhost/onmachinecchannel"; //wcf.Description.ServiceEndpoint _localMachineCommunicationChannel = // new wcf.Description.ServiceEndpoint( // new wcf.Description.ContractDescription(_contract.FullName), // _localMachineBidning, // new wcf.EndpointAddress(address) // ); //_wcfServiceHost.AddServiceEndpoint(_localMachineCommunicationChannel); _wcfServiceHost.AddServiceEndpoint(_contract, _localMachineBidning, address); //LAN Clients _wcfServiceHost.AddServiceEndpoint(_contract, new NetTcpBinding(), "net.tcp://localhost:5000/lanep"); //WAN _wcfServiceHost.AddServiceEndpoint(_contract, new BasicHttpBinding(), "http://localhost:8001/wanep"); //Service Behavior to publish metadata (WSDL Document) wcf.Description.ServiceMetadataBehavior _metadataBehavior = new wcf.Description.ServiceMetadataBehavior(); //Configure Behavior to publish metadata when ServiceHost recieves http-get request _metadataBehavior.HttpGetEnabled = true; //Define URL to download metadata; _metadataBehavior.HttpGetUrl = new Uri("http://localhost:8002/metadata"); // this address used only for metadata download //Add Behavior -> ServieHost _wcfServiceHost.Description.Behaviors.Add(_metadataBehavior); _wcfServiceHost.Open();// ServiceHost availability for Client Requests #endregion #region PatientDataServiceRegistration wcf.ServiceHost _patientDataServiceHost = /* References Behvaior End Point Details From app.config file */ new ServiceHost(typeof(PatientDataServiceLib.PatientDataService)); _patientDataServiceHost.Description.Behaviors.Add(new CustomServiceBehavior()); _patientDataServiceHost.Open(); #endregion Console.ReadKey(); }
/// <summary> /// 构造服务对象 /// </summary> protected void CreateServiceHost() { //创建服务对象 _host = new System.ServiceModel.ServiceHost(ServiceType, new Uri(BaseAddress)); //添加终结点 _host.AddServiceEndpoint(ContractType, Binding, ServiceAddress); }
static void Main(string[] args) { var gamesService = new GamesService(new EFRepository <Game>(new MonolithicStore.DataAccess.AppContext())); System.ServiceModel.ServiceHost host = new System.ServiceModel.ServiceHost(gamesService, new Uri("http://localhost:8733/Design_Time_Addresses/GamesStore")); host.AddServiceEndpoint(typeof(IGamesService), new BasicHttpBinding(), ""); ServiceMetadataBehavior smb = new ServiceMetadataBehavior(); smb.HttpGetEnabled = true; smb.HttpGetUrl = new Uri("http://localhost:8733/Design_Time_Addresses/GamesStore/mex"); host.Description.Behaviors.Add(smb); Console.WriteLine("Opening..."); host.Open(); Console.WriteLine("Opened"); Console.WriteLine("Press exit to exit"); while (Console.ReadLine() != "exit") { } }
static System.ServiceModel.ServiceHost CreateChannel(string url) { BasicHttpBinding binding = new BasicHttpBinding(); Uri address = new Uri(url); Type service = typeof(RemoteRepositoryService.RemoteRepositoryService); System.ServiceModel.ServiceHost host = new System.ServiceModel.ServiceHost(service, address); host.AddServiceEndpoint(typeof(IRemoteRepositoryService), binding, address); return(host); }
static void Main(string[] args) { var baseAddress = new Uri("net.pipe://localhost/WCFIssue"); System.ServiceModel.ServiceHost serviceHost = new System.ServiceModel.ServiceHost(typeof(AdditionService), baseAddress); NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None); serviceHost.AddServiceEndpoint(typeof(IAdditionService), binding, "AdditionService"); serviceHost.Open(); Console.WriteLine($"ServiceHost running at {baseAddress}. Press Return to Exit"); }
static void Main(string[] args) { using (var serviceHost = new System.ServiceModel.ServiceHost(new SpeexStreamer())) { serviceHost.AddServiceEndpoint(typeof(ISpeexStreamer), new NetTcpBinding(), "net.tcp://localhost:8001/SpeexStreamer"); //serviceHost.AddServiceEndpoint(typeof (ISpeexStreamerUp), new BasicHttpBinding(), // "http://localhost:8002/SpeexStreamer"); serviceHost.Open(); Console.WriteLine("Service open..."); Console.ReadLine(); } }
private ServiceHost start(Type wcfType) { Type interfaceType = getContractType(wcfType); String protocolPrefix = null; ServiceMetadataBehavior serviceBehavior = new ServiceMetadataBehavior(); Binding mexBinding = null; if (baseAddress.StartsWith("http://")) { serviceBehavior.HttpGetEnabled = true; mexBinding = MetadataExchangeBindings.CreateMexHttpBinding(); } else if (baseAddress.StartsWith("net.tcp://")) { mexBinding = MetadataExchangeBindings.CreateMexTcpBinding(); } else { throw new NotSupportedException("不支持的协议前缀。" + baseAddress); } //事件参数 ServiceBindingEventArgs args = new ServiceBindingEventArgs(); args.Address = interfaceType.Name; args.ContractInterface = interfaceType; args.ServiceClass = wcfType; args.ServiceMetadataBehavior = serviceBehavior; args.MexEndpointAddress = "mex"; //触发“服务绑定时”事件 if (ServiceBinding != null) { ServiceBinding(this, args); } //得到URL String url = baseAddress + args.Address + "/"; System.ServiceModel.ServiceHost serviceHost = new System.ServiceModel.ServiceHost(wcfType, new Uri(url)); serviceHost.Description.Behaviors.Add(args.ServiceMetadataBehavior); ServiceEndpoint mexEndpoint = new ServiceMetadataEndpoint(mexBinding, new EndpointAddress(url + args.MexEndpointAddress)); serviceHost.AddServiceEndpoint(mexEndpoint); serviceHost.AddDefaultEndpoints(); //打开 serviceHost.Open(); return(serviceHost); }
static void Main(string[] args) { //Uri baseAddress = new Uri("http://localhost:8081/User"); Binding wsBinding = new WSHttpBinding(); System.ServiceModel.ServiceHost host = new System.ServiceModel.ServiceHost(typeof(UserProvider)); host.AddServiceEndpoint(typeof(IUserProvider), wsBinding, "http://localhost:8081/User"); host.Open(); Console.WriteLine("Service Open"); Console.ReadLine(); host.Close(); }
public void Start() { Logging.Log(LogLevelEnum.Info, "Starting WCF service"); ServiceAddress = string.Format("net.tcp://{0}:{1}/", Utilities.GetIPv4Address(Settings.Instance.UseLoopback).ToString(), Settings.Instance.WcfPort); MexServiceAddress = string.Format("net.tcp://{0}:{1}/mex/", Utilities.GetIPv4Address().ToString(), Settings.Instance.WcfMexPort); Logging.Log(LogLevelEnum.Debug, string.Format("Service host address: {0}", ServiceAddress)); Logging.Log(LogLevelEnum.Debug, string.Format("MEX Service host address: {0}", MexServiceAddress)); serviceHost = new ServiceModel.ServiceHost(typeof(TService), new Uri(ServiceAddress)); serviceHost.AddServiceEndpoint(typeof(TContract), new ServiceModel.NetTcpBinding(ServiceModel.SecurityMode.None), ""); // Add TCP MEX endpoint ServiceModelChannels.BindingElement bindingElement = new ServiceModelChannels.TcpTransportBindingElement(); ServiceModelChannels.CustomBinding binding = new ServiceModelChannels.CustomBinding(bindingElement); ServiceModelDescription.ServiceMetadataBehavior metadataBehavior = serviceHost.Description.Behaviors.Find <ServiceModelDescription.ServiceMetadataBehavior>(); if (metadataBehavior == null) { metadataBehavior = new ServiceModelDescription.ServiceMetadataBehavior(); serviceHost.Description.Behaviors.Add(metadataBehavior); } serviceHost.AddServiceEndpoint(typeof(ServiceModelDescription.IMetadataExchange), binding, MexServiceAddress); serviceHost.Open(); Logging.Log(LogLevelEnum.Info, "WCF service started"); }
static void Main(string[] args) { System.ServiceModel.ServiceHost host = new System.ServiceModel.ServiceHost(typeof(ClienteService)); host.AddServiceEndpoint(typeof(IClienteService), new BasicHttpBinding(), new Uri("http://localhost:8080/clientes")); try { host.Open(); Console.ReadLine(); host.Close(); } catch (Exception ex) { Console.WriteLine(ex.Message); host.Abort(); Console.ReadLine(); } }
public void TestTimeoutSet() { var uri = "net.pipe://127.0.0.1/testpipename" + MethodBase.GetCurrentMethod().Name; var binding = new System.ServiceModel.NetNamedPipeBinding() { MaxConnections = 5 }; var timeout = 700; binding.ReceiveTimeout = TimeSpan.FromMilliseconds(timeout); var hang = TimeSpan.FromMilliseconds(timeout * 2); using (var server = new System.ServiceModel.ServiceHost(new Service(), new Uri(uri))) { server.AddServiceEndpoint(typeof(IService), binding, uri); server.Open(); var channelFactory = new System.ServiceModel.ChannelFactory <IService>(binding); var client = channelFactory.CreateChannel(new EndpointAddress(uri)); var result = client.Execute(TimeSpan.FromMilliseconds(0)); Assert.AreEqual(TimeSpan.FromMilliseconds(0), result); CommunicationException timeoutHappenedException = null; try { result = client.Execute(hang); } catch (CommunicationException ex) { timeoutHappenedException = ex; } Assert.NotNull(timeoutHappenedException); Assert.AreEqual(typeof(System.IO.IOException), timeoutHappenedException.InnerException.GetType()); var channel = client as IContextChannel; Assert.AreEqual(CommunicationState.Faulted, channel.State); try { result = client.Execute(TimeSpan.FromMilliseconds(0)); } catch (CommunicationObjectFaultedException afterTimeoutExeption) { } client = channelFactory.CreateChannel(new EndpointAddress(uri)); result = client.Execute(TimeSpan.FromMilliseconds(0)); } }
public void TestTcpUrl() { using (var server = new System.ServiceModel.ServiceHost(new Service(), new Uri("net.tcp://127.0.0.1:6782"))) { var binding = new System.ServiceModel.NetTcpBinding() { MaxConnections = 5 }; server.AddServiceEndpoint(typeof(IService), binding, "net.tcp://127.0.0.1:6782"); server.Open(); Thread.Sleep(100); using (var channelFactory = new System.ServiceModel.ChannelFactory <IService>(binding)) { var client = channelFactory.CreateChannel(new EndpointAddress("net.tcp://127.0.0.1:6782")); var result = client.Execute(new byte[] { 1 }); Assert.AreEqual(1, result[0]); } } }
static void Main(string[] args) { Uri baseAddress = new Uri("http://localhost:9001/TheService"); using (System.ServiceModel.ServiceHost host = new System.ServiceModel.ServiceHost(typeof(TheService), baseAddress)) { host.AddServiceEndpoint(typeof(ITheService), new WSHttpBinding(), ""); ServiceMetadataBehavior serviceBehavior = new ServiceMetadataBehavior(); serviceBehavior.HttpGetEnabled = true; host.Description.Behaviors.Add(serviceBehavior); host.Open(); Console.WriteLine("Hit enter to exit ..."); Console.Read(); host.Close(); } }
private static bool ExecuteTestWithCoverageDataCollection(Func <bool> runTests, string codeCoverageStore) { bool allTestsPassed = true; var ccServer = new CoverageDataCollector(); using (System.ServiceModel.ServiceHost serviceHost = new System.ServiceModel.ServiceHost(ccServer)) { LogInfo("TestHost: Created Service Host."); string address = MarkerV1.CreateCodeCoverageDataCollectorEndpointAddress(); NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None); serviceHost.AddServiceEndpoint(typeof(ICoverageDataCollector), binding, address); serviceHost.Open(); LogInfo("TestHost: Opened _channel."); allTestsPassed = runTests(); LogInfo("TestHost: Finished running test cases."); } ccServer.CoverageData.Serialize(FilePath.NewFilePath(codeCoverageStore)); return(allTestsPassed); }
public static void Main(string[] args) { var httpBaseAddress = new Uri("http://localhost:13666/MessageService"); using (var messageQueueHost = new System.ServiceModel.ServiceHost(typeof(MessageQueue), httpBaseAddress)) { messageQueueHost.AddServiceEndpoint(typeof(IMessageQueue), new WSHttpBinding(), ""); var serviceBehavior = new ServiceMetadataBehavior { HttpGetEnabled = true }; messageQueueHost.Description.Behaviors.Add(serviceBehavior); messageQueueHost.Open(); Console.WriteLine($"Service is live now at: {httpBaseAddress}\n\n"); Console.ReadKey(); messageQueueHost.Close(); } }
public void IContextChannel_operationTimeoutSetGet_Ok() { var address = @"net.pipe://127.0.0.1/" + this.GetType().Name + "_" + MethodBase.GetCurrentMethod().Name; var binding = new NetNamedPipeBinding(); using (var server = new System.ServiceModel.ServiceHost(new SimpleService(), new Uri(address))) { server.AddServiceEndpoint(typeof(ISimpleService), binding, address); server.Open(); Thread.Sleep(100); using (var channelFactory = new System.ServiceModel.ChannelFactory <ISimpleService>(binding)) { var client = channelFactory.CreateChannel(new EndpointAddress(address)); var contextChannel = client as IContextChannel; var newTimeout = TimeSpan.FromSeconds(123); contextChannel.OperationTimeout = newTimeout; var timeout = contextChannel.OperationTimeout; Assert.AreEqual(newTimeout, timeout); } } }
static void Main(string[] args) { //Code wcf.ServiceHost _serverStatusServiceHost = new wcf.ServiceHost(typeof(ServerStatusServiceLib.ServerStatusService)); //rest client (web client) endpoint var endpoint = _serverStatusServiceHost.AddServiceEndpoint( typeof(ServerStatusServiceContractLib.IServerStatusService), new wcf.WebHttpBinding(), "http://localhost:8007/restservice"); //add endpointbehavior to process incoming http request as a rest api request //enable web programming model endpoint.EndpointBehaviors.Add(new WebHttpBehavior()); _serverStatusServiceHost.Open(); Console.WriteLine("Restserver Started"); Console.ReadKey(); }