C# ServiceHost.AddDependencyInjectionBehavior方法代码示例

 public void AddDependencyInjectionBehavior_NullContainer_ThrowsException()
 {
     ServiceHost serviceHost = new ServiceHost(typeof(ServiceType));
     ArgumentNullException exception = Assert.Throws<ArgumentNullException>(
         () => serviceHost.AddDependencyInjectionBehavior(typeof(IContractType), null));
     Assert.Equal("container", exception.ParamName);
 }

        public void Start()
        {
            //SchedulerService
            var schedulerServiceHost = new ServiceHost(typeof(SchedulerService), 
                new Uri("net.pipe://localhost/SchedulerService"));
            schedulerServiceHost.AddServiceEndpoint(typeof(ISchedulerService), new NetNamedPipeBinding(), string.Empty);
            schedulerServiceHost.AddDependencyInjectionBehavior<ISchedulerService>(container);
            hosts.Add(schedulerServiceHost);

            //BoxQueryService
            var boxQueryService = new ServiceHost(typeof(BoxQueryService),
                new Uri("net.pipe://localhost/BoxQueryService"));
            boxQueryService.AddServiceEndpoint(typeof(IBoxQueryService), new NetNamedPipeBinding(), string.Empty);
            boxQueryService.AddDependencyInjectionBehavior<IBoxQueryService>(container);
            hosts.Add(boxQueryService);
            
            //BoxQueryService
            var commonsService = new ServiceHost(typeof(CommonsService),
                new Uri("net.pipe://localhost/CommonsService"));
            commonsService.AddServiceEndpoint(typeof(ICommonsService), new NetNamedPipeBinding(), string.Empty);
            commonsService.AddDependencyInjectionBehavior<ICommonsService>(container);
            hosts.Add(commonsService);

            //StateBrowsingService
            var stateService = new ServiceHost(typeof(StateBrowsingService),
                new Uri("net.pipe://localhost/StateBrowsingService"));
            stateService.AddServiceEndpoint(typeof(IStateBrowsingService), new NetNamedPipeBinding(), string.Empty);
            stateService.AddDependencyInjectionBehavior<IStateBrowsingService>(container);
            hosts.Add(stateService);

            hosts.ForEach(host => host.Open());
        }

 public void AddDependencyInjectionBehavior_NullContractType_ThrowsException()
 {
     ServiceHost serviceHost = new ServiceHost(typeof(ServiceType));
     ArgumentNullException exception = Assert.Throws<ArgumentNullException>(
         () => serviceHost.AddDependencyInjectionBehavior(null, new ContainerBuilder().Build()));
     Assert.That(exception.ParamName, Is.EqualTo("contractType"));
 }

        static void Main(string[] args)
        {
            var builder = AutofacConfig.ConfigureContainer();
            using (var container = builder.Build())
            {
                // Car commands
                var carProtoServer = container.Resolve<ICarProtoServer>();
                carProtoServer.GetInputCommandFactory = () =>
                {
                    var scope = container.BeginLifetimeScope();
                    carProtoServer.OnClientDisconnected = () => scope.Dispose();
                    return scope.Resolve<ICommandFactory>();
                };

                // Wcf
                var address = new Uri("http://localhost:4998");
                var host = new ServiceHost(typeof(CarCommand), address);
                host.AddServiceEndpoint(typeof(ICarCommand), new WSDualHttpBinding(), string.Empty);
                host.AddDependencyInjectionBehavior<CarCommand>(container);
                host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address });
                host.Open();

                Console.WriteLine("Service running");
                Console.ReadLine();

                host.Close();
                Environment.Exit(0);
            }
        }

        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)
        {
            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();
        }

 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 void Run()
        {
            var address = new Uri("http://localhost:8181/contact");
            host = new ServiceHost(typeof(ContactNotificationService), address);
            host.AddServiceEndpoint(typeof(NotificationPort), new BasicHttpBinding(), string.Empty);
            host.AddDependencyInjectionBehavior<ContactNotificationService>(EndpointConfig.Container); // Autofac extension
            host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address });

            Log.Info("Starting");
            host.Open();
            Log.Info("Started");
        }

        private async void App_OnStartup(object sender, StartupEventArgs e) {
            var client = Novaroma.Helper.CreateShellServiceClient();
            bool createdNew;
            try {
                client.Test();
                createdNew = false;
            }
            catch {
                createdNew = true;
            }

            if (!createdNew) {
                if (e.Args.Length > 0)
                    await client.HandleExeArgs(e.Args);
                else
                    await client.ShowMainWindow();

                Current.Shutdown();
                return;
            }

            IoCContainer.Build();

            var engine = IoCContainer.Resolve<INovaromaEngine>();
            engine.LanguageChanged += EngineOnLanguageChanged;

            _shellServiceHost = new ServiceHost(typeof(ShellService), new Uri(Constants.NetPipeUri));
            var shellBinding = new NetNamedPipeBinding {
                MaxReceivedMessageSize = 20000000,
                MaxBufferPoolSize = 20000000,
                MaxBufferSize = 20000000
            };
            _shellServiceHost.AddServiceEndpoint(typeof(IShellService), shellBinding, Constants.NetPipeEndpointName);
            _shellServiceHost.AddDependencyInjectionBehavior<IShellService>(IoCContainer.BaseContainer);
            _shellServiceHost.Open();

            var mainWindow = IoCContainer.Resolve<MainWindow>();
            var mainViewModel = IoCContainer.Resolve<MainViewModel>();
            await mainViewModel.ListData();
            if (!e.Args.Contains("StartHidden"))
                mainWindow.Show();

            _notifyIcon = (TaskbarIcon)FindResource("NotifyIcon");
            if (_notifyIcon != null)
                _notifyIcon.DataContext = IoCContainer.Resolve<NotifyIconViewModel>();

            if (e.Args.Length > 0) {
                var service = IoCContainer.Resolve<IShellService>();
                await service.HandleExeArgs(e.Args);
            }
        }

        public void AddDependencyInjectionBehavior_ContractTypeRegistered_ServiceBehaviorConfigured()
        {
            ContainerBuilder builder = new ContainerBuilder();
            builder.Register(c => new ServiceType()).As<IContractType>();
            IContainer container = builder.Build();

            ServiceHost serviceHost = new ServiceHost(typeof(ServiceType));
            serviceHost.AddDependencyInjectionBehavior(typeof(IContractType), container);

            int serviceBehaviorCount = serviceHost.Description.Behaviors
                .OfType<AutofacDependencyInjectionServiceBehavior>()
                .Count();
            Assert.Equal(1, serviceBehaviorCount);
        }

 public static void Load()
 {
     AutoMapperConfig.Configure(typeof(Core.Bootstrapper.Bootstrap).Assembly, typeof(Bootstrap).Assembly);
     AppDomain.CurrentDomain.SetData("DataDirectory","D:\\");
     var builder = new ContainerBuilder();
     builder.RegisterType<ProjectContext>().AsSelf().SingleInstance();
     builder.RegisterType<FileProviderImpl>().As<IFileProvider>().SingleInstance();
     builder.RegisterType<ProjectProvider>().As<IProjectProvider>().SingleInstance();
     builder.RegisterType<RepositoryProvider>().As<IRepoProvider>().SingleInstance();
     builder.RegisterType<GitHelperSrv>().As<IGitHelperSrv>().InstancePerLifetimeScope();
     Container = builder.Build();
     Host = new ServiceHost(typeof (GitHelperSrv));
     Host.AddDependencyInjectionBehavior<IGitHelperSrv>(Container);
     Host.Open();
     Core.Bootstrapper.Bootstrap.CheckProjects(Container);
 }

        static void Main(string[] args)
        {
            var builder = new ContainerBuilder();
            builder.RegisterModule(new EntitiesModule());
            builder.RegisterModule(new ServicesModule());

            var serviceInformationList =
                new[]
                    {
                        new
                            {
                                Address = "UserRepositoryService",
                                InterfaceType = typeof (IUserRepositoryService),
                                ImplementationType = typeof (UserRepositoryService)
                            }
                    };

            using (var container = builder.Build())
            {
                var serviceHosts = new List<ServiceHost>(serviceInformationList.Length);
                foreach (var serviceInfo in serviceInformationList)
                {
                    var serviceUri = new Uri(ROOT_URI + serviceInfo.Address);
                    var serviceHost = new ServiceHost(serviceInfo.ImplementationType, serviceUri);
                    var debugBehavior = serviceHost.Description.Behaviors.Single(x => x is ServiceDebugBehavior) as ServiceDebugBehavior;
                    debugBehavior.IncludeExceptionDetailInFaults = true;
                    serviceHost.AddServiceEndpoint(serviceInfo.InterfaceType, new NetTcpBinding(), string.Empty);
                    serviceHost.AddDependencyInjectionBehavior(serviceInfo.InterfaceType, container);
                    serviceHost.Open();
                    serviceHosts.Add(serviceHost);
                    Console.WriteLine("Hosted service of type {0} at endpoint {1}", serviceInfo.InterfaceType, serviceUri);
                }

                Console.WriteLine("The host has been opened.");
                Console.ReadLine();

                foreach (var serviceHost in serviceHosts)
                {
                    serviceHost.Close();
                }

                Environment.Exit(0);
            }
        }

        private void btnStartService_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                _host = new ServiceHost(typeof(BlogPostController));
                _host.AddDependencyInjectionBehavior<IBlogPostService>(container);

                _host.Open();

                this.btnStopService.IsEnabled = true;
                this.btnStartService.IsEnabled = false;
                this.lblStatus.Content = "Service is running..";
                this.lblStatus.Foreground = new SolidColorBrush(Colors.RoyalBlue);
            }
            catch (Exception ex)
            {
                container.Dispose();
                MessageBox.Show(ex.Message);
            }
        }

        public void Setup()
        {
            try
            {
                container = Bootstrapper.BuildContainer();

                svcArticleHost = new ServiceHost(typeof(ArticleService), svcArticleServiceURI);
                svcBlogHost = new ServiceHost(typeof(BlogService), svcBlogServiceURI);

                svcArticleHost.AddDependencyInjectionBehavior<Business.Services.Contracts.IArticleService>(container);
                svcBlogHost.AddDependencyInjectionBehavior<Business.Services.Contracts.IBlogService>(container);

                svcArticleHost.Open();
                svcBlogHost.Open();
            }
            catch (Exception ex)
            {
                svcArticleHost = null;
                svcBlogHost = null;
            }
        }

        static void Main(string[] args)
        {
            ContainerBuilder builder = new ContainerBuilder();
            builder.Register(c => new WorkerPoolImpl()).AsImplementedInterfaces().SingleInstance();
            builder.Register(c => new NodeServiceImpl(c.Resolve<WorkerPool>())).As<NodeService>();
            builder.RegisterType<PrimeCalculatorImpl>().AsImplementedInterfaces();
            builder.RegisterType<SeederImpl>().AsImplementedInterfaces();

            using (IContainer container = builder.Build())
            {
                Uri address = new Uri(ConfigurationManager.AppSettings["host"]);
                ServiceHost host = new ServiceHost(typeof(NodeServiceImpl), address);

                host.AddServiceEndpoint(typeof(NodeService),
                    new WSDualHttpBinding(WSDualHttpSecurityMode.None)
                        {
                            SendTimeout = new TimeSpan(0, 0, 10),
                            ReceiveTimeout = new TimeSpan(0, 0, 10),
                            MaxBufferPoolSize = 1024 * 1024 * 1,
                            MaxReceivedMessageSize = 1024 * 1024 * 20,
                            MessageEncoding = WSMessageEncoding.Mtom,
                            ReaderQuotas =
                                new XmlDictionaryReaderQuotas
                                {
                                    MaxArrayLength = 1000000,
                                }
                        }, string.Empty);
                host.AddDependencyInjectionBehavior<NodeService>(container);
                host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true, HttpGetUrl = address });
                host.Open();

                var calc = container.Resolve<PrimeCalculator>();
                WriteFile(calc.Calc(GetTaskFromInFile()));

                host.Close();
                Environment.Exit(0);
            }
        }