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"));
}
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());
}
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);
}
}
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();
}
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();
}
}
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 loader = new MacroMoney.Boostrapper.Loader();
loader.Load();
Console.WriteLine("Starting up services...");
Console.WriteLine("");
SM.ServiceHost hostAccountManager = new SM.ServiceHost(typeof(AccountManager));
hostAccountManager.AddDependencyInjectionBehavior <IAccountService>(IoC.Container);
SM.ServiceHost hostTransactionmanager = new SM.ServiceHost(typeof(TransactionManager));
hostTransactionmanager.AddDependencyInjectionBehavior <ITransactionService>(IoC.Container);
SM.ServiceHost hostUserManager = new SM.ServiceHost(typeof(UserManager));
hostUserManager.AddDependencyInjectionBehavior <IUserService>(IoC.Container);
SM.ServiceHost hostCategoryManager = new SM.ServiceHost(typeof(CategoryManager));
hostCategoryManager.AddDependencyInjectionBehavior <ICategoryService>(IoC.Container);
StartService(hostAccountManager, "AccountManager");
StartService(hostTransactionmanager, "TransactionManager");
StartService(hostUserManager, "UserManager");
StartService(hostCategoryManager, "CategoryManager");
//System.Timers.Timer timer = new System.Timers.Timer(10000);
//timer.Elapsed += OnTimerElapsed;
//timer.Start();
//Console.WriteLine("Reservation monitor started.");
Console.WriteLine("");
Console.WriteLine("Press [Enter] to exit.");
Console.ReadLine();
Console.WriteLine("");
//timer.Stop();
//Console.WriteLine("Reservaton mointor stopped.");
StopService(hostAccountManager, "AccountManager");
StopService(hostTransactionmanager, "TransactionManager");
StopService(hostUserManager, "UserManager");
}
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);
}
}
static void Main(string[] args)
{
AutoMapperConfig.RegisterMappings();
var builder = new ContainerBuilder();
builder.RegisterAssemblyModules(AppDomain.CurrentDomain.GetAssemblies());
using (var container = builder.Build())
{
using (var host = new ServiceHost(typeof(ContractService)))
{
var binding = new BasicHttpBinding();
host.AddServiceEndpoint(typeof(IContractService), binding, string.Empty);
host.AddServiceEndpoint(typeof(ISalaryService), binding, string.Empty);
host.AddDependencyInjectionBehavior<ContractService>(container);
host.Open();
Console.WriteLine("Host started @ " + DateTime.Now);
Console.ReadLine();
}
}
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<PluginService>();
builder.Register<IPluginServiceHost>(c =>
{
var scope = c.Resolve<ILifetimeScope>();
var cfg = c.Resolve<IConfiguration>();
var uri = new Uri(string.Format(cfg.PluginUrlTemplate, "core"));
var binding = new NetHttpBinding
{
HostNameComparisonMode = HostNameComparisonMode.Exact,
MaxBufferPoolSize = 10485760,
MaxReceivedMessageSize = 10485760,
};
var host = new ServiceHost(typeof(PluginService));
host.AddServiceEndpoint(typeof(IPluginService), binding, uri);
host.AddDependencyInjectionBehavior(typeof(PluginService), scope);
return new PluginServiceHost(host);
});
}
public void AddDependencyInjectionBehaviorWithGenericArgument_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<IContractType>(container);
int serviceBehaviorCount = serviceHost.Description.Behaviors
.OfType<AutofacDependencyInjectionServiceBehavior>()
.Count();
Assert.That(serviceBehaviorCount, Is.EqualTo(1));
}
public void Start()
{
var services = _knownServices.ToArray();
Log.InfoFormat("Запуск WCF-хоста для {0} сервисов", services.Length);
var hostName = _config.GetAppSettingString("Zen/Hostname");
if (string.IsNullOrEmpty(hostName)) hostName = "localhost";
var port = _config.GetAppSettingString("Zen/Port");
if (string.IsNullOrEmpty(port)) port = "8080";
foreach (var knownService in services)
{
Log.DebugFormat("Запуск хостов для типа: {0}", knownService.GetType().Name);
IWebService service = knownService;
var scope = AppScope.BeginScope(b => b.Register(ctx => this).As<WebserviceHostApplication>());
_hostScopes.Add(scope);
_hostThreads.Add(new Thread(() =>
{
var uriStr = string.Format("http://{0}:{1}/{2}", hostName, port, service.GetWebserviceName());
Uri address = new Uri(uriStr);
foreach (
var webService in
service.GetType()
.GetInterfaces()
.Where(i =>
i.GetCustomAttributes(typeof (ServiceContractAttribute), true).Any()
&& i != typeof (IWebService)))
{
try
{
Log.DebugFormat("Запуск хостов для типа: {0} по контракту {1}", service.GetType().Name,
webService.Name);
ServiceHost host = new ServiceHost(service.GetType(), address);
host.AddServiceEndpoint(webService, new BasicHttpBinding(), string.Empty);
host.AddDependencyInjectionBehavior(webService, scope.Scope);
host.Description.Behaviors.Add(new ServiceMetadataBehavior
{
HttpGetEnabled = true,
HttpGetUrl = address
});
_hosts.Add(host);
host.Open();
var sb = new StringBuilder();
foreach (var ep in host.Description.Endpoints)
{
sb.AppendFormat(
"Для контракта: {1} сервиса {2} производится прослушивание по адресу {0}",
ep.Address.Uri.AbsoluteUri,
ep.Contract.Name,
service.GetType().Name)
.AppendLine();
}
Log.Info(sb.ToString());
var enumService = scope.Resolve<EnumeratorWebservice>();
if (enumService != null) enumService.RegisterService(service);
}
catch (Exception ex)
{
Log.Error(string.Format("Ошибка инициализации веб-сервиса {1}:{0}", webService.Name,
service.GetType().Name), ex);
}
}
}));
}
foreach (var hostThread in _hostThreads)
{
hostThread.Start();
}
}
private void Run()
{
Console.WriteLine("Run a ServiceHost via programmatic configuration...");
Console.WriteLine();
string baseAddress = "http://" + Environment.MachineName + ":8000/Service.svc";
Console.WriteLine("BaseAddress: {0}", baseAddress);
using (ServiceHost serviceHost = new ServiceHost(typeof(SalesService), new Uri(baseAddress)))
{
WebHttpBinding webBinding = new WebHttpBinding
{
ContentTypeMapper = new RawContentMapper(),
MaxReceivedMessageSize = 4194304,
MaxBufferSize = 4194304
};
serviceHost.AddServiceEndpoint(typeof(ISalesService), webBinding, "json")
.Behaviors.Add(new WebHttpJsonNetBehavior());
//serviceHost.AddServiceEndpoint(typeof(ISalesService), new BasicHttpBinding(), baseAddress);
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();
}
}
public void AddDependencyInjectionBehavior_SingleInstanceContextMode_ServiceBehaviorIgnored()
{
ContainerBuilder builder = new ContainerBuilder();
builder.Register(c => new SingletonServiceType()).As<IContractType>();
IContainer container = builder.Build();
ServiceHost serviceHost = new ServiceHost(typeof(SingletonServiceType));
serviceHost.AddDependencyInjectionBehavior(typeof(IContractType), container);
int serviceBehaviorCount = serviceHost.Description.Behaviors
.OfType<AutofacDependencyInjectionServiceBehavior>()
.Count();
Assert.That(serviceBehaviorCount, Is.EqualTo(0));
}
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;
}
