public void Configuration(IAppBuilder app)
{
var container = App_Start.DependencyInjectionConfig.CreateContainer();
container.Verify(SimpleInjector.VerificationOption.VerifyAndDiagnose);
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
SimpleInjectorServiceHostFactory.SetContainer(container);
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
HttpConfiguration config = new HttpConfiguration();
config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
config.MessageHandlers.Add(new TokenValidationHandler());
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/form-data"));
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
//var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
ConfigureJwt(app);
app.UseWebApi(config);
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=316888
}
protected void Application_Start(object sender, EventArgs e)
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.RegisterWcfServices(Assembly.GetExecutingAssembly());
//dbcontext
//container.Register<DbContext>(() =>
//{
// return new ApplicationDbContext();
//});
container.Register <ApplicationDbContext>(Lifestyle.Scoped);
//metadata services
//container.Register<ICustomerTableService, CustomerService>(Lifestyle.Transient);
container.Register <IProductTableService, ProductTableService>(Lifestyle.Transient);
container.Register <ISaleDetailService, SaleDetailService>(Lifestyle.Transient);
container.Register <ISalesTableService, SalesTableService>(Lifestyle.Transient);
container.Register <IUserService, UserTableService>(Lifestyle.Transient);
//business logic service
container.Register <IProductService, ProductService>(Lifestyle.Scoped);
container.Register <ISaleService, SaleService>(Lifestyle.Scoped);
container.Register <IUserLoginService, UserLoginService>(Lifestyle.Scoped);
container.Register <IUnitOfWork, UnitOfWork>(Lifestyle.Scoped);
//container.Verify();
//SimpleInjectorServiceHostFactory.SetContainer(container);
// 4. Store the container for use by the application
container.Verify();
SimpleInjectorServiceHostFactory.SetContainer(container);
}
public override void OnStart()
{
// Will be called the first time windows service is started!
Tasks = new List <Task>();
// Configure the DI and dependencies and intitialize the Manager
Logger.Information("OnStart [S]" + DateTime.Now);
var container = ConfigureDependency.Configure();
SimpleInjectorServiceHostFactory.SetContainer(container);
Logger.Information("Configuring dependencies");
var changeTrackingManager = container.GetInstance <ISqlTrackingManager>();
changeTrackingManager.logger = this.Logger;
Logger.Information("Initialsing the change tracking manager!");
cancellationTokenSource = new CancellationTokenSource();
Tasks.Add(changeTrackingManager.ProcessChangedTables(cancellationTokenSource.Token));
// Initialise wcf service host
// Wcf Service Instance
var wcfService = container.GetInstance <IChangeTrackingSubscriptions>();
wcfService.Logger = this.Logger;
_ServiceHost = WcfServiceHost.GetServiceHost(wcfService);
Logger.Information("OnStart [E]" + DateTime.Now);
}
static ServiceContainer()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
// Register WCF services.
container.RegisterWcfServices(Assembly.GetExecutingAssembly());
container.Register <ApplicationDbContext>(Lifestyle.Scoped);
//metadata services
//container.Register<ICustomerTableService, CustomerService>(Lifestyle.Transient);
container.Register <IProductTableService, ProductTableService>(Lifestyle.Scoped);
container.Register <ISaleDetailService, SaleDetailService>(Lifestyle.Scoped);
container.Register <ISalesTableService, SalesTableService>(Lifestyle.Scoped);
container.Register <IUserService, UserTableService>(Lifestyle.Scoped);
//business logic service
container.Register <IProductService, ProductService>(Lifestyle.Scoped);
container.Register <ISaleService, SaleService>(Lifestyle.Scoped);
container.Register <IUserLoginService, UserLoginService>(Lifestyle.Scoped);
container.Register <IUnitOfWork, UnitOfWork>(Lifestyle.Scoped);
//container.Verify();
//SimpleInjectorServiceHostFactory.SetContainer(container);
// 4. Store the container for use by the application
container.Verify();
SimpleInjectorServiceHostFactory.SetContainer(container);
Container = container;
}
public static void Initialize()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.RegisterSingleton <Configuration>();
container.RegisterSingleton <IConfiguration>(container.GetInstance <Configuration>);
container.RegisterSingleton <IUpdateConfiguration>(container.GetInstance <Configuration>);
container.RegisterSingleton <IConfigurationReader, ConfigurationReader>();
container.RegisterSingleton <IActivityLogger, ActivityLogger>();
container.Register <IMapper <Operation, Db.Models.Operation>, OperationMapper>();
container.Register <IMapper <Db.Models.Operation, Operation>, Dal.Mappers.DbToDto.OperationMapper>();
container.Register <IResultSenderService, ResultSenderService>();
container.Register <IQueueWatcher, QueueWatcher>();
container.Register <ICalculationAgregator, CalculationAgregator>();
container.Register <ICalculationEngine, CalculationEngine>();
container.Register <ICalculationHelper, CalculationHelper>();
container.Register <IQueueRepository, QueueRepository>();
//container.RegisterWcfServices(Assembly.GetExecutingAssembly());
container.Verify();
SimpleInjectorServiceHostFactory.SetContainer(container);
var reader = container.GetInstance <IConfigurationReader>();
reader.ReadConfiguration();
}
static Bootstrapper()
{
var container = new Container();
RegionalAssemblies.Add("Tz.Singapore_ParcelDomainService");
RegionalAssemblies.Add("Tz.Hongkong_ParcelDomainService");
// register all your components with the container here:
// container.Register<IService1, Service1>()
// container.RegisterLifetimeScope<IDataContext,DataContext>();
//container.Register<IDbContextFactory, ParcelDbContextFactory>();
IConnectionString iconnection = new GlobalConnectionFetcher();
container.RegisterSingle(typeof(IConnectionString), iconnection);
var parcelDomainFactory = new RegionalParcelDomainFactory(container, iconnection);
//container.RegisterSingle<IRegionalFactory,RegionalParcelDomainFactory>();//, parcelDomainFactory);
container.RegisterSingle(typeof(IRegionalFactory), parcelDomainFactory);
//container.Register<IRegionalFactory, RegionalParcelDomainFactory>(wcfLifeTime);
LoadAssemblies(container);
container.Verify();
Container = container;
SimpleInjectorServiceHostFactory.SetContainer(container);
}
public static void RegisterDependencyContainer(Container container)
{
container.RegisterTypes();
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
SimpleInjectorServiceHostFactory.SetContainer(container);
}
public static void Bootstrap()
{
_contenedor = new Container();
SimpleInjectorServiceHostFactory.SetContainer(_contenedor);
RegistrarWcfDependencias();
_contenedor.Verify();
}
/// <summary>
/// First method to be called upon startup.
/// </summary>
public static void AppInitialize()
{
log4net.Config.XmlConfigurator.Configure();
// register DI.
var container = SimpleInjectorRegistartion();
SimpleInjectorServiceHostFactory.SetContainer(container);
}
protected void Application_Start(object sender, EventArgs e)
{
using (var container = new Container())
{
AutoMapperConfig.RegisterMappings();
container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
SimpleInjectorServiceHostFactory.SetContainer(container);
SimpleInjectorWcfInitializer.Initialize();
}
}
protected void Application_Start(object sender, EventArgs e)
{
// Create the container as usual.
var container = new Container();
container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
// Register your types, for instance:
container.Register <IEmployeeRepository, EmployeeRepository>();
// Register the container to the SimpleInjectorServiceHostFactory.
SimpleInjectorServiceHostFactory.SetContainer(container);
}
private void InitializeSimpleInjectorSettings()
{
var container = new SimpleInjector.Container();
//container.Options.DefaultScopedLifestyle = new SimpleInjector.Integration.Wcf.WcfOperationLifestyle();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.RegisterWcfServices(System.Reflection.Assembly.GetExecutingAssembly());
new SimpleInjectorConfigurator(container).Configure();
new SimpleInjectorWebCommonProcessorConfigurator(container).Configure();
new SimpleInjectorQueryProcessorConfigurator(container).Configure();
SimpleInjectorServiceHostFactory.SetContainer(container);
}
protected void Application_Start(object sender, EventArgs e)
{
// Create the container as usual.
var container = new Container();
container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
BootStrapper.RegisterServices(container);
// Register the container to the SimpleInjectorServiceHostFactory.
SimpleInjectorServiceHostFactory.SetContainer(container);
AutoMapperConfig.RegisterMappings();
}
public static void Initialize()
{
Container container = new Container();
container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
InitializeContainer(container);
SimpleInjectorServiceHostFactory.SetContainer(container);
EventoDominio.Container = new ContainerWCF(container);
container.Verify();
}
/// <summary>Initialize the container and register it for the WCF ServiceHostFactory.</summary>
public static void Initialize()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
InitializeContainer(container);
container.RegisterWcfServices(Assembly.GetExecutingAssembly());
//container.Verify();
SimpleInjectorServiceHostFactory.SetContainer(container);
// TODO: Add the following attribute to all .svc files:
// Factory="SimpleInjector.Integration.Wcf.SimpleInjectorServiceHostFactory, SimpleInjector.Integration.Wcf"
}
public static void Install()
{
//
// Create a new Simple Injector container
var container = new Container();
//
// Register
container.Register <IDbContextScopeFactory, DbContextScopeFactory>();
container.Register <IAmbientDbContextLocator, AmbientDbContextLocator>();
container.Register <IRepositoryFactory, RepositoryFactory <AppDbContext> >();
container.Register <IUserService, UserService>();
container.Register <ISubscriptionService, SubscriptionService>();
//
// 4. Register container as default DependencyResolver
// Register the container to the SimpleInjectorServiceHostFactory.
SimpleInjectorServiceHostFactory.SetContainer(container);
}
protected void Application_Start()
{
Container container = new Container();
container.RegisterWcfServices(Assembly.GetExecutingAssembly());
IPackage[] packages = new IPackage[]
{
new DataPackage(),
new WebServicesPackage(),
new CommonPackage()
};
foreach (var package in packages)
{
package.RegisterServices(container);
}
SimpleInjectorServiceHostFactory.SetContainer(container);
}
public static Container Init()
{
var _container = new Container();
_container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
_container.Register <IRepoFactory, RepoFactory>();
_container.Register <ITestRepo1, TestRepo1>();
_container.Register <ITestRepo2, TestRepo2>();
_container.Register <ITestRepo3, TestRepo3>();
_container.Register <ITestService, TestService>(Lifestyle.Singleton);
_container.Register <IService1, Service1>();
Container = _container;
// Register the container to the SimpleInjectorServiceHostFactory.
SimpleInjectorServiceHostFactory.SetContainer(_container);
_container.Verify();
return(_container);
}
public static Container Build()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
// Override defualt behavior to inject properties
container.Options.PropertySelectionBehavior = new ImportPropertySelectionBehavior();
// resolve primitive and string parameters via appSettings using Typename.paramName as the key
container.Options.RegisterParameterConvention(new TypenameArgumentNameParameterConvention());
container.Register <IService, SampleService>(Lifestyle.Scoped);
// NOTE this will not be analyzed y .Verify / Analyze
container.Register <Lazy <IService> >(() => new Lazy <IService>(container.GetInstance <IService>));
container.Register <ISecondService, DisposableSecondService>(Lifestyle.Scoped);
container.Register <ILogger, DebugLogger>(Lifestyle.Scoped);
container.Register <ITaskRunner, FakeTaskRunner>(Lifestyle.Scoped);
// Registering ITaskRunner decorators...
// Decorators are applied in the order in which they are registered, so
// FakeTaskRunner is wrapped by
// LoggingTaskRunnerDecorator, which is wrapped by wraps
// TransactionalTaskRunnerDecorator
container.RegisterDecorator <ITaskRunner, LoggingTaskRunnerDecorator>(Lifestyle.Scoped);
container.RegisterDecorator <ITaskRunner, TransactionalTaskRunnerDecorator>(Lifestyle.Scoped);
//container.RegisterWcfServices(typeof(FooService).Assembly);
// Fails when FooService implements IDisposable if I call .RegisterWcfServices
// but given the factory in .svc file, this is not needed
// anyway, it seems service instances do not get disposed
// No trace from FooService.Dispose()
// Needs further inspection
// TODO what is FooService indeed implements IDisposable?
container.Verify();
SimpleInjectorServiceHostFactory.SetContainer(container);
return(container);
}
public static Container Init()
{
var container = IocContainer.Container; // new Container();
container.Options.DefaultScopedLifestyle = new SimpleInjector.Lifestyles.AsyncScopedLifestyle();
RegisterDBContexts(container);
container.Register <ICache, LocalMemoryCache>(Lifestyle.Singleton);
RegisterFactories(container);
RegisterServices(container);
RegisterBusinessEngines(container);
RegisterRepositories(container);
RegisterMaps(container);
RegisterEntityServices(container);
container.Verify();
// try { container.Verify(); } catch { }
SimpleInjectorServiceHostFactory.SetContainer(container);
return(container);
}
static void Main(string[] args)
{
// Create the container as usual.
var container = new Container();
container.Options.DefaultScopedLifestyle = new WcfOperationLifestyle();
// Register your types, for instance:
DataBootStraper.BootStrap(container);
container.Register <IRelationshipGroupService, RelationshipGroupManager>();
// Register the container to the SimpleInjectorServiceHostFactory.
SimpleInjectorServiceHostFactory.SetContainer(container);
Console.WriteLine("Starting up services...");
Console.WriteLine("");
//SM.ServiceHost host = new SM.ServiceHost(typeof(RelationshipGroupManager));
var hostRelationshipGroupManager = new SimpleInjectorServiceHost(container, typeof(RelationshipGroupManager), new Uri[0]);
var hostLifeEventManager = new SimpleInjectorServiceHost(container, typeof(LifeEventManager), new Uri[0]);
StartService(hostRelationshipGroupManager, "Relationship Group");
StartService(hostLifeEventManager, " LifeEvents ");
Console.WriteLine("");
Console.WriteLine("Press [Enter] to exit.");
Console.ReadLine();
StopService(hostRelationshipGroupManager, "Relationship Group");
StopService(hostLifeEventManager, "LifeEvents");
Console.ReadLine();
}
protected void Application_Start(object sender, EventArgs e)
{
SimpleInjectorServiceHostFactory.SetContainer(DependencyConfig.Container);
}
/// <summary>
/// 当应用启动时调用（优先级高于 Startup 类）
/// </summary>
protected void Application_Start(object sender, EventArgs e)
{
Container = new Container();
RegisterServices();
SimpleInjectorServiceHostFactory.SetContainer(Container);
}
/// <summary>
/// Injects the WCF.
/// </summary>
public void InjectWcf()
{
// Register the container to the SimpleInjectorServiceHostFactory.
SimpleInjectorServiceHostFactory.SetContainer(_container);
}
