public ServiceHost Initialize() { _serviceHost = CreateServiceHost(); _serviceHost.AddDependencyInjectionBehavior <TContract>(_lifetimeScope); _serviceHost.Open(); return(_serviceHost); }
public async Task Fact1() { IServiceCollection services = new ServiceCollection(); services.AddScoped <ITestService, TestServicePerCall>(); services.AddSingleton(new Dependency { Initial = 1 }); using (var provider = services.BuildServiceProvider()) { using (ServiceHost host = new ServiceHost(typeof(TestServicePerCall), new Uri("net.tcp://localhost:5000"))) { host.AddServiceEndpoint(typeof(ITestService), binding, "/service1"); host.AddDependencyInjectionBehavior <ITestService>(provider); await host.OpenAsync(); using (var client = ChannelFactory <ITestServiceClient> .CreateChannel(binding, new EndpointAddress("net.tcp://localhost:5000/service1"))) { var result = client.Operation(); Assert.Equal(2, result); result = client.Operation(); Assert.Equal(2, result); } await host.CloseAsync(); } } }
public static void Main() { Console.Title = "Server"; AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; AppDomain.CurrentDomain.FirstChanceException += CurrentDomain_FirstChanceException; var builder = new ContainerBuilder(); builder.RegisterType <MyServiceImplementation>().As <IMyService>(); // == Register mutator via Autofac, currently done via NServiceBus bus configuration. See below! // builder.RegisterType<MyMutator>().AsImplementedInterfaces().AsSelf().InstancePerLifetimeScope(); builder.RegisterType <MyUnitOfWork>().AsImplementedInterfaces().InstancePerLifetimeScope(); var container = builder.Build(); InitBus(container); using (var host = new ServiceHost(typeof(MyServiceImplementation))) { host.AddDependencyInjectionBehavior <IMyService>(container); host.Open(); Console.WriteLine("Press *any* key to quit"); Console.ReadKey(); host.Close(); } }
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(); }
static void HostNetTcpService(IContainer container) { // Create two different URIs to serve as the base address // One for http requests and another for net.tcp Uri netTcpUrl = new Uri("net.tcp://localhost:8080/ArticleNetTcpService"); //Create ServiceHost to host the service in the console application netTcpHost = new ServiceHost(typeof(ArticleService), netTcpUrl); // Enable metadata exchange - you need this so others can create proxies // to consume your WCF service ServiceMetadataBehavior serviceMetaBehavior = new ServiceMetadataBehavior(); netTcpHost.Description.Behaviors.Add(serviceMetaBehavior); netTcpHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "mex"); // Set dependency injection netTcpHost.AddDependencyInjectionBehavior <IArticleService>(container); // Start the Service netTcpHost.Open(); Console.WriteLine("IArticleService Service is host at " + DateTime.Now.ToString()); Console.WriteLine(); }
private void AddFleeterService() { var endpoint = new Uri(baseEndpoint + "fleeter"); var host = new ServiceHost(typeof(FleeterService), endpoint); host.AddServiceEndpoint(typeof(IFleeterService), new WSHttpBinding(), ""); host.AddDependencyInjectionBehavior <IFleeterService>(_lifetimeScope); host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpsGetEnabled = true }); try { host.Open(); log.LogInformation($"Started FleeterService on {endpoint}"); } catch (Exception ex) { log.LogError(ex, $"Could not start FleeterService {endpoint}"); } _services.Add(host); }
static void Main(string[] args) { var builder = new ContainerBuilder(); // Register your service implementations. builder.RegisterModule(new WcfServices.AutofacModule()); //var container = builder.Build(); using (var container = builder.Build()) { //Uri address = new Uri("http://localhost:9001/NoteService"); ServiceHost host = new ServiceHost(typeof(NoteService));//, address); //host.AddServiceEndpoint(typeof(INoteService), new BasicHttpBinding(), string.Empty); // Here's the important part - attaching the DI behavior to the service host // and passing in the container. host.AddDependencyInjectionBehavior <INoteService>(container); //host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address }); host.Open(); ServiceHost host2 = new ServiceHost(typeof(UserService));//, address); host2.AddDependencyInjectionBehavior <IUserService>(container); host2.Open(); Console.WriteLine("The hosts have been opened."); Console.ReadLine(); host.Close(); Environment.Exit(0); } }
public static void Main(string[] args) { using (var container = AutofacConfig.Configure()) { var uri = new Uri(ConfigurationManager.AppSettings["uri"]); using (var serviceHost = new ServiceHost(typeof(RemoteNotesService), uri)) { var logger = container.Resolve <IRemoteNotesLogger <Program> >(); try { serviceHost.AddDependencyInjectionBehavior <IRemoteNotesService>(container); serviceHost.Open(); logger.Info($"Service {uri} was running."); Console.WriteLine("Press any key to exit..."); Console.ReadKey(); serviceHost.Close(); logger.Info($"Service {uri} was stopped."); } catch (Exception ex) { logger.Error($"The following exception was thrown: '{ex.Message}'. Stack trace: '{ex.StackTrace}'."); Console.WriteLine("Press any key to exit..."); Console.ReadKey(); } } } }
static void Main() { var assemblies = GetAssemblies(); var types = assemblies .SelectMany(assembly => assembly.GetTypes()) .Where(type => type.IsClass && type.GetInterfaces().Any(y => y.IsDefined(typeof(ServiceContractAttribute)))) .ToList(); var container = Bootstrapper.BuildContainer(assemblies); Console.WriteLine("ServiceHost"); try { foreach (var type in types) { var serviceHost = new ServiceHost(type); serviceHost.AddDependencyInjectionBehavior(type, container); serviceHost.Open(); } } catch (Exception e) { Console.WriteLine(e.Message); } Console.WriteLine("Started"); Console.ReadKey(); }
static void Main(string[] args) { Container = AutofacBuilder.ConfigByJson(JSON_FILE_NAME); //using (ServiceHost host = new ServiceHost(typeof(WcfConversationService))) //{ // host.AddDependencyInjectionBehavior<IWcfConversationService>(Container); // host.Open(); // Console.WriteLine("Service hosted successfully"); // Console.ReadKey(true); //} ServiceHost host = new ServiceHost(typeof(WcfConversationService)); host.AddDependencyInjectionBehavior <IWcfConversationService>(Container); host.Open(); foreach (var item in host.BaseAddresses) { Console.WriteLine(item.AbsoluteUri); } Console.WriteLine("Service hosted successfully"); Console.ReadKey(true); }
public static void Main(string[] args) { AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper; var builder = new ContainerBuilder(); // TODO: separate these to modules builder.RegisterType <UserService>().As <IUserService>(); builder.RegisterType <MappingService>().As <IMappingService>(); builder.RegisterType <Service.Implementation.UserService>().As <Service.Contracts.IUserService>(); builder.RegisterType <GuidWrapper>().As <IGuidWrapper>(); builder.RegisterType <DateTimeWrapper>().As <IDateTimeWrapper>(); builder.RegisterType <UserStore>().As <IStore <User> >(); builder.RegisterType <UserQuery>().As <IUserQuery>(); var mapperConfig = new MapperConfigurationExpression(); new WcfMappingConfiguration().Configure(mapperConfig); new EfCoreMappingConfiguration().Configure(mapperConfig); Mapper.Initialize(mapperConfig); using (var container = builder.Build()) { using (var serviceHost = new ServiceHost(typeof(UserService))) { serviceHost.AddDependencyInjectionBehavior <IUserService>(container); serviceHost.Open(); Console.WriteLine("The service is listening..."); Console.WriteLine("Press <Enter> to stop the service."); Console.ReadLine(); } } }
static void Main(string[] args) { ContainerBuilder builder = new ContainerBuilder(); builder.RegisterType <DependencyComponent>().As <IDependency>(); builder.RegisterType <SampleService>(); Container = builder.Build(); ServiceHost host = new ServiceHost(typeof(SampleService)); host.AddDependencyInjectionBehavior(typeof(SampleService), Container); host.Open(); Console.WriteLine("Service is running. Press 'Enter' to call operation."); Console.ReadLine(); Console.WriteLine(); ChannelFactory <ISampleService> channelFactory = new ChannelFactory <ISampleService>(""); ISampleService proxy = channelFactory.CreateChannel(); proxy.PerformOperation(); Console.WriteLine(); Console.WriteLine("Press 'Enter' to end."); Console.ReadLine(); }
static void Main(string[] args) { IContainer container = null; ContainerBuilder builder = new ContainerBuilder(); builder.RegisterAssemblyTypes(typeof(ZipCodeRepository).Assembly) .Where(t => t.Name.EndsWith("Repository")) .As(t => t.GetInterfaces().FirstOrDefault( i => i.Name == "I" + t.Name)); builder.RegisterType <GeoManager>(); container = builder.Build(); ServiceHost hostGeoManager = new ServiceHost(typeof(GeoManager)); hostGeoManager.AddDependencyInjectionBehavior(typeof(GeoManager), container); hostGeoManager.Open(); Console.WriteLine("Services started. Press [Enter] to exit."); Console.ReadLine(); hostGeoManager.Close(); }
private void Run() { Console.WriteLine("Run a ServiceHost via administrative configuration..."); Console.WriteLine(); using (ServiceHost serviceHost = new ServiceHost(typeof(SalesService))) { serviceHost.AddDependencyInjectionBehavior <ISalesService>(AutofacHostFactory.Container); Console.WriteLine("Opening the host"); serviceHost.Open(); try { AutofacHostFactory.Container.Resolve <ISalesService>(); Console.WriteLine("The service is ready."); Console.WriteLine("Press <ENTER> to terminate service."); } catch (Exception ex) { Console.WriteLine("Error on initializing the service host."); Console.WriteLine(ex.Message); } Console.WriteLine(); Console.ReadLine(); serviceHost.Close(); } }
static void Main(string[] args) { Console.OutputEncoding = Encoding.UTF7; try { var authHost = new ServiceHost(typeof(AuthService)); var registrationHost = new ServiceHost(typeof(RegistrationService)); var userHost = new ServiceHost(container.Resolve <UserService>()); authHost.AddDependencyInjectionBehavior <AuthService>(container); registrationHost.AddDependencyInjectionBehavior <RegistrationService>(container); userHost.AddDependencyInjectionBehavior <UserService>(container); userHost.Open(); Console.WriteLine("User Service Started..."); authHost.Open(); Console.WriteLine("Auth Service Started..."); registrationHost.Open(); Console.WriteLine("Register Service Started..."); Console.ReadLine(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
public static void Main(string[] args) { using (var host = new ServiceHost(typeof(NameService))) { //host.AddServiceEndpoint(typeof(INameService), new BasicHttpBinding(), "http://localhost:46468/NameService"); //host.AddServiceEndpoint(typeof(INameService), new BasicHttpBinding(), "http://localhost:9562/NameService"); //if(host.Description.Behaviors.Find<ServiceMetadataBehavior>() == null) //{ // var metadataBehavior = new ServiceMetadataBehavior(); // metadataBehavior.HttpGetEnabled = true; // metadataBehavior.HttpGetUrl = new Uri("http://localhost:46468/NameService/meta"); // host.Description.Behaviors.Add(metadataBehavior); // host.Opened += Host_Opened; // host.Open(); // Console.ReadKey(); //} host.Opened += Host_Opened; host.Open(); ContainerBuilder containerBuilder = new ContainerBuilder(); containerBuilder.RegisterType <Services>().As <IServices>(); host.AddDependencyInjectionBehavior <IServices>(containerBuilder.Build()); Console.ReadKey(); } Console.WriteLine("hello word"); }
private static void EndPointIntilaize(Autofac.IContainer container, BasicHttpBinding bind) { Uri address = new Uri("http://localhost:8081/test/"); ServiceHost host = new ServiceHost(typeof(Test1Service), address); host.AddServiceEndpoint(typeof(ITest1Service), bind, string.Empty); host.AddDependencyInjectionBehavior <ITest1Service>(container); host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address }); host.Open(); Uri address2 = new Uri("http://localhost:8081/user/"); ServiceHost host2 = new ServiceHost(typeof(UserService), address2); host2.AddServiceEndpoint(typeof(IUserService), bind, string.Empty); host2.AddDependencyInjectionBehavior <IUserService>(container); host2.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address2 }); host2.Open(); Uri address4 = new Uri("http://localhost:8081/RoleService/"); ServiceHost host4 = new ServiceHost(typeof(RoleService), address4); host4.AddServiceEndpoint(typeof(IRoleService), bind, string.Empty); host4.AddDependencyInjectionBehavior <IRoleService>(container); host4.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address4 }); host4.Open(); }
public void AddDependencyInjectionBehavior_NullContainer_ThrowsException() { ServiceHost serviceHost = new ServiceHost(typeof(ServiceType)); ArgumentNullException exception = Assert.Throws <ArgumentNullException>( () => serviceHost.AddDependencyInjectionBehavior(typeof(IContractType), null)); Assert.That(exception.ParamName, Is.EqualTo("container")); }
public void AddDependencyInjectionBehavior_NullParameters_ThrowsException() { ServiceHost serviceHost = new ServiceHost(typeof(ServiceType)); ArgumentNullException exception = Assert.Throws <ArgumentNullException>( () => serviceHost.AddDependencyInjectionBehavior(typeof(IContractType), new ContainerBuilder().Build(), null)); Assert.Equal("parameters", exception.ParamName); }
public bool Start() { host = new ServiceHost(typeof(HelloWorldService)); host.AddDependencyInjectionBehavior <IHelloWorldService>(scope); host.Open(); logger.Info("The host has been opened."); return(true); }
protected override Task ExecuteAsync(CancellationToken stoppingToken) { var builder = new ContainerBuilder(); builder.RegisterType <UnitOfWork>().As <IUnitOfWork>().WithParameter(new TypedParameter(typeof(string), "DefaultConnection")); builder.RegisterType <Test1Service>().As <ITest1Service>(); builder.RegisterType <UserService>().As <IUserService>(); builder.RegisterType <Service.RoleService>().As <IRoleService>(); var bind = new BasicHttpBinding { MaxBufferPoolSize = int.MaxValue, MaxBufferSize = int.MaxValue, MaxReceivedMessageSize = int.MaxValue, ReceiveTimeout = TimeSpan.MaxValue, OpenTimeout = TimeSpan.MaxValue, SendTimeout = TimeSpan.MaxValue, TransferMode = TransferMode.Buffered }; using (var container = builder.Build()) { Uri address = new Uri("http://localhost:8081/test/"); ServiceHost host = new ServiceHost(typeof(Test1Service), address); host.AddServiceEndpoint(typeof(ITest1Service), bind, string.Empty); host.AddDependencyInjectionBehavior <ITest1Service>(container); host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address }); host.Open(); _logger.LogInformation("The host of " + host.Description.Name.ToString() + " has been opened."); Uri address2 = new Uri("http://localhost:8081/user/"); ServiceHost host2 = new ServiceHost(typeof(UserService), address2); host2.AddServiceEndpoint(typeof(IUserService), bind, string.Empty); host2.AddDependencyInjectionBehavior <IUserService>(container); host2.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address2 }); host2.Open(); _logger.LogInformation("The host of " + host2.Description.Name.ToString() + " has been opened."); Uri address4 = new Uri("http://localhost:8081/RoleService/"); ServiceHost host4 = new ServiceHost(typeof(RoleService), address4); host4.AddServiceEndpoint(typeof(IRoleService), bind, string.Empty); host4.AddDependencyInjectionBehavior <IRoleService>(container); host4.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address4 }); host4.Open(); _logger.LogInformation("The host of " + host4.Description.Name.ToString() + " has been opened."); return(ExecuteAsync(stoppingToken)); } }
static void HostServices() { using (var container = InitBuilder().Build()) { // Create two different URIs to serve as the base address // One for http requests and another for net.tcp Uri httpUrl = new Uri("http://localhost:8090/BlogHttpService"); Uri netTcpUrl = new Uri("net.tcp://localhost:8080/ArticleNetTcpService"); //Create ServiceHost to host the service in the console application httpHost = new ServiceHost(typeof(BlogService), httpUrl); netTcpHost = new ServiceHost(typeof(ArticleService), netTcpUrl); // Enable metadata exchange - you need this so others can create proxies // to consume your WCF service ServiceMetadataBehavior httpServiceMetaBehavior = new ServiceMetadataBehavior(); ServiceMetadataBehavior netTcpServiceMetaBehavior = new ServiceMetadataBehavior(); httpHost.Description.Behaviors.Remove(typeof(ServiceDebugBehavior)); httpHost.Description.Behaviors.Add( new ServiceDebugBehavior { IncludeExceptionDetailInFaults = true }); httpServiceMetaBehavior.HttpGetEnabled = true; httpHost.Description.Behaviors.Add(httpServiceMetaBehavior); netTcpHost.Description.Behaviors.Add(netTcpServiceMetaBehavior); netTcpHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "mex"); // Set dependency injection httpHost.AddDependencyInjectionBehavior <IBlogService>(container); netTcpHost.AddDependencyInjectionBehavior <IArticleService>(container); // Start the Services httpHost.Open(); netTcpHost.Open(); Console.WriteLine("IBlogService Service is host at " + DateTime.Now.ToString()); Console.WriteLine("IArticleService Service is host at " + DateTime.Now.ToString()); Console.WriteLine(); Console.WriteLine("Press any key to terminate.."); Console.ReadKey(); if (httpHost != null && httpHost.State == CommunicationState.Opened) { httpHost.Close(); } if (netTcpHost != null && netTcpHost.State == CommunicationState.Opened) { netTcpHost.Close(); } } }
public ServerManager(IContainer container) { this.container = container; serviceHost = new ServiceHost(typeof(T)); serviceHost.AddDependencyInjectionBehavior <T1>(container); serviceHost.Faulted += ServiceHostFaulted; serviceHost.UnknownMessageReceived += ServiceHostUnknownMessageReceived; serviceHost.Description.Behaviors.Add(container.Resolve <HtmlServiceBehavior>()); }
private static ServiceHost CreateTestServiceHost(ILifetimeScope container) { var host = new ServiceHost(typeof(TestService), TestServiceAddress); host.AddServiceEndpoint(typeof(ITestService), new BasicHttpBinding(), ""); host.AddDependencyInjectionBehavior <ITestService>(container); host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = TestServiceAddress }); return(host); }
public void Fact3() { using (ServiceHost host = new ServiceHost(typeof(TestServiceSingle), new Uri("net.tcp://localhost:5002"))) { using (var provider = new ServiceCollection().BuildServiceProvider()) { host.AddDependencyInjectionBehavior <ITestService>(provider); Assert.False(host.Description.Behaviors.Contains(typeof(ServiceProviderServiceBehavior))); } } }
public DeployerServiceHost(Uri baseAddress, ILifetimeScope lifetimeScope) { _host = new ServiceHost(typeof(DeployerService), baseAddress); var binding = new WSHttpBinding { Security = { Mode = SecurityMode.None } }; var endpoint = _host.AddServiceEndpoint(typeof(IDeployerService), binding, typeof(IDeployerService).Name); var container = new ContainerAdapter(lifetimeScope); _host.AddDependencyInjectionBehavior <IDeployerService>(container); TraceHelper.TraceInformation(TraceSwitches.TfsDeployer, "DeployerService will listen at {0}", endpoint.ListenUri); }
public void AddDependencyInjectionBehavior_ContractTypeNotRegistered_ThrowsException() { ServiceHost serviceHost = new ServiceHost(typeof(ServiceType)); Type contractType = typeof(IContractType); ArgumentException exception = Assert.Throws <ArgumentException>( () => serviceHost.AddDependencyInjectionBehavior(contractType, new ContainerBuilder().Build())); Assert.Equal("contractType", exception.ParamName); string message = string.Format(ServiceHostExtensionsResources.ContractTypeNotRegistered, contractType.FullName); Assert.Contains(message, exception.Message); }
public HostedWcfService(IServiceProvider serviceProvider) { if (ServiceDescription.GetService(typeof(TService)).IsInstanceContextModeSingle()) { host = new ServiceHost(serviceProvider.GetRequiredService <TContract>()); } else { host = new ServiceHost(typeof(TService)); host.AddDependencyInjectionBehavior <TContract>(serviceProvider); } }
static void Main(string[] args) { // Workaround the CLR Threadpool issue ThreadPoolTimeoutWorkaround.DoWorkaround(); IContainer container = CreateContainer(); var benchmarkService = new ServiceHost(typeof(BenchmarkService)); benchmarkService.AddDependencyInjectionBehavior <BenchmarkService>(container); benchmarkService.Open(); Console.WriteLine("service is up"); Console.ReadLine(); }
/// <summary> /// Start the module. /// </summary> public override void Start() { base.Start(); try { ServiceHost = new ServiceHost(typeof(ClientConnectorReal)); //autofac DI ServiceHost.AddDependencyInjectionBehavior <IClientConnector>(IocManager.Container); //绑定服务行为 ServiceMetadataBehavior behavior = ServiceHost.Description.Behaviors. Find <ServiceMetadataBehavior>(); if (behavior == null) { behavior = new ServiceMetadataBehavior(); behavior.HttpGetEnabled = true; ServiceHost.Description.Behaviors.Add(behavior); } else { behavior.HttpGetEnabled = true; } //启动事件 ServiceHost.Opened += delegate { var Logger = LoggerPool.GetLogger(""); Logger.Info("Host-->Endpoint:" + ServiceHost.Description.Endpoints.FirstOrDefault().Address); Logger.Info("Host-->Service started:" + ServiceHost.Description.ConfigurationName); }; ServiceHost.Closed += delegate { var Logger = LoggerPool.GetLogger(""); Logger.Info("Host-->Endpoint:" + ServiceHost.Description.Endpoints.FirstOrDefault().Address); Logger.Info("Host-->Service closed:" + ServiceHost.Description.ConfigurationName); }; Thread th = new Thread(ServiceHost.Open); th.Start(); IocManager.Register <IServiceHostProvider>(new DefaultServiceHostProvider(ServiceHost)); } catch (Exception ex) { var Logger = LoggerPool.GetLogger(""); Logger.Error(ex.Message, ex); } }