public static void Register(Container container)
{
container.Register(typeof (IQueryHandler<,>), new[] {typeof (IQueryHandler<,>).Assembly});
container.Register(typeof (ICommandHandler<,>), new[] {typeof (ICommandHandler<,>).Assembly});
container.RegisterCollection(typeof (IHyperMediaState), typeof (IHyperMediaState).Assembly);
container.Register<IBoardState, BoardState>();
container.Register<IBoardTaskState, BoardTaskState>();
container.Register<IBoardColumnState, BoardColumnState>();
container.Register<ISlugService, SlugService>();
container.Register<ICommandDispatcher, CommandDispatcher>();
container.Register<IQueryDispatcher, QueryDispatcher>();
container.Register<ILinkFactory, LinkFactory>();
container.Register<IHyperMediaFactory, HyperMediaFactory>();
container.Register<IMappingService, MappingService>();
container.RegisterWebApiRequest<IDataContext, DataContext>();
container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
container.EnableHttpRequestMessageTracking(GlobalConfiguration.Configuration);
container.RegisterSingleton<IRequestMessageProvider>(new RequestMessageProvider(container));
container.Register<IValidator<Board>, BoardValidator>();
container.Register<IValidator<BoardColumn>, BoardColumnValidator>();
container.Register<IValidator<BoardTask>, BoardTaskValidator>();
container.Verify();
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
}
public void Configuration(IAppBuilder app)
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new ExecutionContextScopeLifestyle();
InitializeContainer(container);
container.Verify();
app.Use(async(context, next) =>
{
using (container.BeginExecutionContextScope())
{
await next();
}
});
var config = new HttpConfiguration();
ConfigureOAuth(app);
//config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(this.Container);
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
//app.UseWebApi(config);
}
private static void InitializeContainer(Container container)
{
container.Register<ICardRepository, CardRepository>();
// For instance:
// container.Register<IUserRepository, SqlUserRepository>(Lifestyle.Scoped);
}
private static void Bootstrap()
{
container = new SimpleInjector.Container();
container.Register <IUsersService, UserServices>();
container.Register <Iunitofwork, SampleContext>();
container.Register <frm_AddEdit>();
}
static NewExpression BuildNewExpression(Container container,
ConstructorInfo constructor,
ParameterExpression[] funcParameterExpression)
{
var ctorParameters = constructor.GetParameters();
var ctorParameterTypes = ctorParameters.Select(p => p.ParameterType).ToArray();
var funcParameterTypes = funcParameterExpression.Select(p => p.Type).ToArray();
var funcParametersIndex = IndexOfSubCollection(ctorParameterTypes, funcParameterTypes);
if (funcParametersIndex == -1)
{
throw new ActivationException(
$"The constructor of type {constructor.DeclaringType.FullName} did not contain the sequence of the following " +
$"constructor parameters: {string.Join(", ", funcParameterTypes.Select(t => t.Name))}.");
}
var firstCtorParameterExpressions = ctorParameterTypes
.Take(funcParametersIndex)
.Select(type => container.GetRegistration(type, true).BuildExpression());
var lastCtorParameterExpressions = ctorParameterTypes
.Skip(funcParametersIndex + funcParameterTypes.Length)
.Select(type => container.GetRegistration(type, true).BuildExpression());
var expressions = firstCtorParameterExpressions
.Concat(funcParameterExpression)
.Concat(lastCtorParameterExpressions)
.ToArray();
return(Expression.New(constructor, expressions));
}
public async Task CreateSimpleHttpServer_RoutingWithHttpAttributes_ReplaceService()
{
using (var httpServer = new OwinHttpServer(new UriBuilder("http://localhost:5001/")))
{
var container = new SimpleInjector.Container();
var resetEvent = new ManualResetEventSlim();
RegisterExceptionLogger(ref container, resetEvent);
httpServer.AddDependencyResolver(() => new SimpleInjectorWebApiDependencyResolver(container))
.SetHttpRouteAttributes()
.ReplaceService <IExceptionLogger>((serviceResolver) =>
{
IExceptionLogger exceptionLogger = serviceResolver.GetService(typeof(IExceptionLogger)) as IExceptionLogger;
return(exceptionLogger);
}).TryStart();
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:5001/");
var result = await client.GetAsync($"/Device/state/{1}?active=false");
resetEvent.Wait();
Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode);
}
}
public void SetUp()
{
container = new Container();
container.RegisterAsEasyNetQContainerFactory();
bus = new MockBuilder().Bus;
}
public static void Initialize()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();
// Chamada dos módulos do Simple Injector
InitializeContainer(container);
// Necessário para registrar o ambiente do Owin que é dependência do Identity
// Feito fora da camada de IoC para não levar o System.Web para fora
container.RegisterPerWebRequest(() =>
{
if (HttpContext.Current != null && HttpContext.Current.Items["owin.Environment"] == null && container.IsVerifying())
{
return new OwinContext().Authentication;
}
return HttpContext.Current.GetOwinContext().Authentication;
});
container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
container.Verify();
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
}
public MessageChannel(Container container, RabbitMQServer server, ICommandDiscovery commandDiscovery, IEventDiscovery eventDiscovery)
{
_container = container;
_server = server;
_commandDiscovery = commandDiscovery;
_eventDiscovery = eventDiscovery;
}
private static void BenchSimpleInjector()
{
var services = new ServiceCollection();
services.AddScoped <IValueProvider, ValueProvider>();
services.AddLogging();
var container = new SimpleInjector.Container();
services.AddSimpleInjector(container);
services.BuildServiceProvider().UseSimpleInjector(container);
Launch("SimpleInjector (ThreadScoped)", (i) =>
{
using (var serviceScope = ThreadScopedLifestyle.BeginScope(container))
{
var valueProvider = serviceScope.GetRequiredService <IValueProvider>();
valueProvider.GetValue(i);
}
});
Launch("SimpleInjector (AsyncScopedLifestyle)", (i) =>
{
using (var serviceScope = AsyncScopedLifestyle.BeginScope(container))
{
var valueProvider = serviceScope.GetRequiredService <IValueProvider>();
valueProvider.GetValue(i);
}
});
}
private static void InitSiteContainer(Container container)
{
container.Register<Fx.Domain.Account.IService.IAccountService, Fx.Domain.Account.UserAccountService>();
container.Register<Fx.Domain.FxSite.IService.IChannelService, Fx.Domain.FxSite.ChannelService>();
container.Register<Fx.Domain.FxSite.IService.ISite, Fx.Domain.FxSite.SiteService>();
container.Register<Fx.Domain.FxSite.IService.IGoods, Fx.Domain.FxSite.GoodsService>();
container.Register<Fx.Domain.FxSite.IService.ICar, Fx.Domain.FxSite.CarService>();
container.Register<Fx.Domain.FxSite.IService.IHouse, Fx.Domain.FxSite.HouseService>();
//FxGoods
container.Register<Fx.Domain.FxGoods.IService.ITransferGoods, Fx.Domain.FxGoods.FxTransferGoodService>();
container.Register<Fx.Domain.FxGoods.IService.IBuyGoods, Fx.Domain.FxGoods.FxBuyGoodsService>();
//FxCar
container.Register<Fx.Domain.FxCar.IService.ITransferCar, Fx.Domain.FxCar.FxTransferCarService>();
container.Register<Fx.Domain.FxCar.IService.IBuyCar, Fx.Domain.FxCar.FxBuyCarService>();
//FxHouse
container.Register<Fx.Domain.FxHouse.IService.ITransferHouse, Fx.Domain.FxHouse.FxTransferHouseService>();
container.Register<Fx.Domain.FxHouse.IService.IBuyHouse, Fx.Domain.FxHouse.FxBuyHouseService>();
//�������
container.RegisterSingle<Fx.Infrastructure.Caching.ICacheManager, Fx.Infrastructure.Caching.CacheManager>();
}
private static void MapRoutes(HttpConfiguration config, Container container)
{
config.Routes.MapHttpRoute(
name: "QueryApi",
routeTemplate: "api/queries/{query}",
defaults: new { },
constraints: new { },
handler: new QueryDelegatingHandler(
handlerFactory: container.GetInstance,
queryTypes: Bootstrapper.GetKnownQueryTypes()));
config.Routes.MapHttpRoute(
name: "CommandApi",
routeTemplate: "api/commands/{command}",
defaults: new { },
constraints: new { },
handler: new CommandDelegatingHandler(
handlerFactory: container.GetInstance,
commandTypes: Bootstrapper.GetKnownCommandTypes()));
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional });
}
public static void Register(Container container)
{
container.RegisterOpenGeneric(typeof(IRepository<>), typeof(Repository<>));
// Single services
container.Register<IContext, DefaultContext>();
container.Register<ICommandPersister, DefaultCommandPersister>();
container.Register<ICommandSerializer, NewtonsoftCommandSerializer>();
//container.Register<ICommandSerializer, JilCommandSerializer>();
AddInterfaceForEachDerivedType(container, typeof(TableBase), typeof(ITableBeforeSave<>));
AddInterfaceForEachDerivedType(container, typeof(TableBase), typeof(ITableAfterSave<>));
AddInterfaceForEachDerivedType(container, typeof(CommandBase), typeof(ICommandBeforeProcess<>));
AddInterfaceForEachDerivedType(container, typeof(CommandBase), typeof(ICommandBeforeSave<>));
AddInterfaceForEachDerivedType(container, typeof(CommandBase), typeof(ICommandAfterSave<>));
// default persister
container.RegisterOpenGeneric(typeof(ICommandSave<>), typeof(DefaultSaver<>));
// override persisters
container.Options.AllowOverridingRegistrations = true;
//container.RegisterOpenGeneric(typeof(InsertCommandFor<>), typeof(SimpleCommandsDefaultSaver<>));
//container.RegisterManyForOpenGeneric(typeof(ICommandSave<>), AppDomain.CurrentDomain.GetAssemblies());
//container.RegisterManyForOpenGeneric(typeof(ICommandSave<>).MakeGenericType(typeof(InsertCommandFor<>)), AppDomain.CurrentDomain.GetAssemblies());
/*
ReplaceInterfaceForEachDerivedType(container,
typeof(SimpleCommand<>),
typeof(ICommandSave<>).MakeGenericType(typeof(InsertCommandFor<>))
);*/
//RegisterAllPersisters();
}
protected void Application_Start()
{
log4net.Config.XmlConfigurator.Configure();
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
container.Register<IUserService, UserService>(Lifestyle.Scoped);
container.Register<IUserRepository, UserHibernateRepository>(Lifestyle.Scoped);
container.Register<IAssetService, AssetService>(Lifestyle.Scoped);
container.Register<IAssetViewService, AssetViewService>(Lifestyle.Scoped);
container.Register<IAssetRepository, AssetHibernateRepository>(Lifestyle.Scoped);
container.Register<ITokenService, TokenService>(Lifestyle.Scoped);
container.Register<ITokenRepository, TokenHibernateRepository>(Lifestyle.Scoped);
container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
container.Verify();
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
// Web API configuration and services
// Web API routes
WebApiConfig.Register(GlobalConfiguration.Configuration);
}
public void RegisterServices(Container container)
{
//Config
container.RegisterWebApiRequest<IDbSettings>(() => new DbSettings(Constants.ConnectionName));
//DbContext
container.RegisterWebApiRequest<IPropertyMatrixContext>(() => new PropertyMatrixContext(container.GetInstance<IDbSettings>()));
//Services
container.Register<IPriceRangeService, PriceRangeService>();
container.Register<IQuoteService, QuoteService>();
container.Register<IAppointmentService, AppointmentService>();
container.Register<ISearchService, SearchService>();
//Data
container.Register<IPriceRangeRepository, PriceRangeRepository>();
container.Register<IQuoteRepository, QuoteRepository>();
container.Register<IAppointmentRepository, AppointmentRepository>();
container.Register<ISearchRepository, SearchRepository>();
//Mapping
container.Register<IMapToExisting<PriceRange, PriceRange>, PriceRangeMapper>();
//Reference Generator
container.Register<IReferenceGenerator, CryptographicReferenceGenerator>();
container.Verify();
}
static void Main(string[] args)
{
Console.WriteLine("DEMO >> DbSet");
var contenedor = new SimpleInjector.Container();
contenedor.Register <IConeccion, Coneccion>(Lifestyle.Singleton);
contenedor.Register <Productos>(Lifestyle.Singleton);
var productos = contenedor.GetInstance <Productos>();
var a = productos.Crear();
a.Descripcion = "Coca cola";
a.Precio = 90;
productos.Agregar(a);
Pausa();
a.PonerOferta();
productos.Actualizar(a);
Pausa();
productos.Borrar(a);
Pausa();
var ps = productos.Traer("Precio < 90");
}
// Invoked once at startup to configure your application.
public void Configuration(IAppBuilder builder)
{
var config = new HttpConfiguration();
// Create the container as usual.
var container = new Container();
// Register your types, for instance using the RegisterWebApiRequest
// extension from the integration package:
container.RegisterWebApiRequest<IUserRepository, SqlUserRepository>();
// This is an extension method from the integration package.
container.RegisterWebApiControllers(config);
container.Verify();
config.DependencyResolver =
new SimpleInjectorWebApiDependencyResolver(container);
config.MapHttpAttributeRoutes();
//config.Routes.MapHttpRoute("Default", "", new { controller = "OEmbed" });
//config.Formatters.XmlFormatter.UseXmlSerializer = true;
//config.Formatters.Remove(config.Formatters.JsonFormatter);
////config.Formatters.Remove(config.Formatters.XmlFormatter);
// config.Formatters.JsonFormatter.UseDataContractJsonSerializer = true;
builder.UseWebApi(config);
//builder.Use(async (context, next) => {
// using (container.BeginExecutionContextScope())
// {
// await next();
// }
//});
}
// This code configures Web API contained in the class Startup, which is additionally specified as the type
// parameter in WebApplication.Start
public void Configuration(IAppBuilder appBuilder)
{
// Add SimpeInjector package.
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
// Add SimpleInjector.Integration.WebApi package.
container.Register<IValuesService, ValuesService>(new WebApiRequestLifestyle());
// Configure Web API for Self-Host
// HttpConfiguration located in Microsoft.AspNet.WebApi.Core package.
HttpConfiguration config = new HttpConfiguration();
// Add System.Web reference to avoid "Missing ..." error.
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
// UseWebApi extension method located in Microsoft.AspNet.WebApi.OwinSelfHost package.
appBuilder.UseWebApi(config);
}
/// <summary>
/// Loads the module into the kernel.
/// </summary>
/// <param name="container">The container.</param>
public void register_components(Container container)
{
Log.InitializeWith<Log4NetLog>();
IConfigurationSettings configuration = new ConfigurationSettings();
Config.initialize_with(configuration);
container.Register(() => configuration, Lifestyle.Singleton);
container.Register<IEventAggregator, EventAggregator>(Lifestyle.Singleton);
container.Register<IMessageSubscriptionManagerService, MessageSubscriptionManagerService>(Lifestyle.Singleton);
EventManager.initialize_with(container.GetInstance<IMessageSubscriptionManagerService>);
container.Register<INotificationSendService, SmtpMarkdownNotificationSendService>(Lifestyle.Singleton);
container.Register<IMessageService, MessageService>(Lifestyle.Singleton);
container.Register<IEmailDistributionService, EmailDistributionService>(Lifestyle.Singleton);
container.Register<IDateTimeService, SystemDateTimeUtcService>(Lifestyle.Singleton);
container.Register<ICommandExecutor, CommandExecutor>(Lifestyle.Singleton);
container.Register<IFileSystemService, FileSystemService>(Lifestyle.Singleton);
container.Register<IFileSystem, DotNetFileSystem>(Lifestyle.Singleton);
container.Register<IRegularExpressionService, RegularExpressionService>(Lifestyle.Singleton);
container.Register<INuGetService, NuGetService>(Lifestyle.Singleton);
container.Register<IPackageValidationService, PackageValidationService>(Lifestyle.Singleton);
container.Register<ITypeLocator, TypeLocator>(Lifestyle.Singleton);
RegisterOverrideableComponents(container, configuration);
}
public override bool OnStart()
{
var container = new Container();
try
{
// Building IoC container
Initialize(container);
container.Verify();
// Initializers
var initializers = new List<IInitializable>
{
container.GetInstance<TraceListenersInitializer>(),
container.GetInstance<DiagnosticsInitializer>()
};
foreach (IInitializable initializer in initializers)
{
initializer.Initialize();
}
}
catch (Exception e)
{
Trace.TraceError("Failed to start BillingSync worker role: {0}", e);
throw;
}
_container = container;
return base.OnStart();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Allow Any Certificates
// This should not be the same in Production
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;
// Create the container as usual.
var container = new Container();
container.Options.PropertySelectionBehavior = new ImportPropertySelectionBehavior();
container.Register<IErrorSignaler, ErrorSignaler>(Lifestyle.Singleton);
container.Register<IHttpClientHelper, HttpClientHelper>(Lifestyle.Singleton);
container.Register<IConfigurationHelper, ConfigurationHelper>(Lifestyle.Singleton);
// SI Attributes Dependency Injection
container.RegisterInitializer<BlogApiAuthorizationAttribute>(a => a.ErrorSignaler = container.GetInstance<ErrorSignaler>());
container.RegisterInitializer<BlogAuthorizationAttribute>(a => a.ErrorSignaler = container.GetInstance<ErrorSignaler>());
// This is an extension method from the integration package.
container.RegisterMvcControllers(System.Reflection.Assembly.GetExecutingAssembly());
container.RegisterMvcIntegratedFilterProvider();
container.Verify();
DependencyResolver.SetResolver(new SimpleInjector.Integration.Web.Mvc.SimpleInjectorDependencyResolver(container));
}
protected void Application_Start()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
// Register your types, for instance using the scoped lifestyle:
container.Register<IUnitOfWork, UnitOfWork>(Lifestyle.Scoped);
container.Register<IUserManager, UserManager>();
container.Register<IOrderManagerEx, OrderManagerEx>();
// This is an extension method from the integration package.
container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
container.Verify();
GlobalConfiguration.Configuration.DependencyResolver =
new SimpleInjectorWebApiDependencyResolver(container);
AutoMapperConfig.Configure();
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
log4net.Config.XmlConfigurator.Configure(new FileInfo(Server.MapPath("~/Web.config")));
}
/// <summary>
/// Registers the service locater.
/// </summary>
/// <param name="container">The container.</param>
private void RegisterServiceLocator(Container container)
{
try
{
container.Register<IPageDataRepository, PageDataRepository>(Lifestyle.Singleton);
container.Register<IPageItemDataRepository, PageItemDataRepository>(Lifestyle.Singleton);
container.Register<IEventDataRepository, EventDataRepository>(Lifestyle.Singleton);
container.Register<IUserInfoDataRepository, UserInfoDataRepository>(Lifestyle.Singleton);
container.Register<IFavoriteImageDataRepository, FavoriteImageDataRepository>(Lifestyle.Singleton);
container.Register<IFavoritePageDataRepository, FavoritePageDataRepository>(Lifestyle.Singleton);
container.Register<IUserImageDataRepository, UserImageDataRepository>(Lifestyle.Singleton);
container.Register<IBannerDataRepository, BannerDataRepository>(Lifestyle.Singleton);
container.Register<IBannerItemDataRepository, BannerItemDataRepository>(Lifestyle.Singleton);
container.Register<IPageBannerDataRepository, PageBannerDataRepository>(Lifestyle.Singleton);
container.Register<ISplashImageDataRepository, SplashImageDataRepository>(Lifestyle.Singleton);
container.Register<IHitCounterDataRepository, HitCounterDataRepository>(Lifestyle.Singleton);
container.Register<IHitCounterDetailDataRepository, HitCounterDetailDataRepository>();
container.Register<IDeviceRegistryDataRepository, DeviceRegistryDataRepository>(Lifestyle.Singleton);
container.Register<INotificationLogDataRepository, NotificationLogDataRepository>(Lifestyle.Singleton);
}
catch (Exception ex)
{
ex.ExceptionValueTracker(container);
}
}
public async Task CreateSimpleHttpServer_RoutingWithHttpAttributes_RoutedMiddleware()
{
var httpServer = new OwinHttpServer(new UriBuilder("http://localhost:5000/"));
var container = new SimpleInjector.Container();
var resetEvent = new ManualResetEventSlim();
RegisterManualResetEvent(ref container, resetEvent);
httpServer.AddDependencyResolver(() => new SimpleInjectorWebApiDependencyResolver(container))
.SetHttpRouteAttributes()
.AddMiddleware((iocResolver) =>
{
var _resetEvent = iocResolver.GetService(typeof(ManualResetEventSlim));
return(new OwinMiddlewareRegistration(typeof(TestOwinMiddleware), new object[] { _resetEvent }, "/WebSockets"));
});
HttpClient client = CreateHttpClient(CreateTestServer(httpServer));
client.BaseAddress = new Uri("http://localhost");
var result = await client.GetAsync($"/WebSockets/");
resetEvent.Wait();
Assert.Equal(HttpStatusCode.Redirect, result.StatusCode);
}
public void RegisterServices(Container container)
{
container.RegisterPerWebRequest<IUserStore<User>>(() => new UserStore<User>(container.GetInstance<IdentityDbContext<User>>()));
container.RegisterPerWebRequest(() => container.IsVerifying()
? new OwinContext(new Dictionary<string, object>()).Authentication
: HttpContext.Current.GetOwinContext().Authentication);
}
public void RegisterDependencies(Container container)
{
container.Register <ITaskRepository, TaskRepository>();
container.Register <NewLeadService, NewLeadService>();
container.Verify();
}
protected CollectionResolver(Container container, Type serviceType)
{
Requires.IsNotPartiallyClosed(serviceType, nameof(serviceType));
this.Container = container;
this.ServiceType = serviceType;
}
protected virtual void Setup()
{
_container = new Container();
_container.Options.AllowOverridingRegistrations = true;
foreach (var registrar in GetRegistrars().OrderBy(x => x.Order))
registrar.Register(_container);
}
public override void Configure(Container container)
{
container.Register<IConsole, SystemConsole>();
container.Register<IThreadService, ThreadService>();
ViewEngines.Add<RazorViewEngine>();
}
/// <summary>
/// Constructor. Creates a new TypeRegistrationProvider instance.
/// </summary>
/// <param name="container">SimpleInjector Container instance</param>
/// <param name="options">Registration options to use to auto-register types.</param>
public TypeRegistrationProvider(Container container, IAutoRegistrationOptions options)
{
this.container = container;
this.options = options;
this.container.Options.AllowOverridingRegistrations = true;
}
public static void RegistrationContainers()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();
container.Register<IUnitOfWork, UnitOfWork>(Lifestyle.Scoped);
container.Register<IAddressManager, AddressManager>();
container.Register<ICarManager, CarManager>();
container.Register<ICoordinatesManager, CoordinatesManager>();
container.Register<IDistrictManager, DistrictManager>();
container.Register<ILocationManager, LocationManager>();
container.Register<IPersonManager, PersonManager>();
container.Register<ITarifManager, TarifManager>();
container.Register<IUserManager, UserManager>();
container.Register<IDriverLocationHelper, DriverLocationHelper>();
container.Register<IWorkerStatusManager, WorkerStatusManager>();
container.Register<ISupportManager, SupportManager>();
container.Register<IOrderManagerEx, OrderManagerEx>();
container.Register<IDriverExManager, DriverExManager>();
container.Register<ITariffExManager, TariffExManager>();
container.Register<IFeedbackManager, FeedbackManager>();
container.Register<INewsManager, NewsManager>();
container.Verify();
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
}
public static Container Configuration(Container kernel)
{
kernel.Register<ICommercialRepository, CommercialRepository>(Lifestyle.Singleton);
kernel.Verify();
return kernel;
}
//Register Container for classes that use dependecy Injection
private Container ConfigureSimpleInjector(IAppBuilder app)
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new ExecutionContextScopeLifestyle();
container.Register<IUserStore<User, int>, UserStore>(Lifestyle.Scoped);
container.Register<IDatabaseFactory, DatabaseFactory>(Lifestyle.Scoped);
container.Register<IUnitOfWork, UnitOfWork>();
container.Register<IAuthRepository, AuthRepository>();
container.Register<ICommentRepository, CommentRepository>();
container.Register<IUserRepository, UserRepository>();
container.Register<ICompanyProfileRepository, CompanyProfileRepository>();
container.Register<IInsuranceAgentProfileRepository, InsuranceAgentProfileRepository>();
container.Register<ILeadProductRepository, LeadProductRepository>();
container.Register<ILeadTransactionRepository, LeadTransactionRepository>();
container.Register<IReviewPostRepository, ReviewPostRepository>();
app.Use(async (context, next) => {
using (container.BeginExecutionContextScope())
{
await next();
}
});
container.Verify();
return container;
}
private static void RunApp(Container container)
{
try
{
XamlGeneratedNamespace.GeneratedApplication app = new XamlGeneratedNamespace.GeneratedApplication();
((WpfApplication)container.GetInstance<IApplication>()).Initialize();
app.InitializeComponent();
app.Startup += (sender, args) =>
{
ThemeManager.AddAccent("WhiteAccent",
new Uri("pack://application:,,,/DSImager.Application;component/Themes/WhiteAccent.xaml"));
ThemeManager.AddAppTheme("WhiteTheme",
new Uri("pack://application:,,,/DSImager.Application;component/Themes/WhiteTheme.xaml"));
};
var mainWin = container.GetInstance<MainWindow>();
container.GetInstance<ILogService>().Trace(LogEventCategory.Informational, "App is starting");
app.Run(mainWin);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
/// <summary>Initialize the container and register it as MVC3 Dependency Resolver.</summary>
public static void Initialize()
{
var container = new Container();
InitializeContainer(container);
try
{
container.Verify();
}
catch (Exception exception)
{
Trace.TraceError("{0}", exception);
throw;
}
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
GlobalConfiguration.Configuration.Services.Replace(typeof (IFilterProvider), new SimpleInjectorWebApiFilterProvider(container));
try
{
new TraceListenersInitializer(container.GetInstance<IPortalSettings>(), container.GetInstance<IEmailSenderService>()).Initialize();
}
catch (Exception e)
{
Trace.TraceError("Failed to initialize trace listeners: {0}", e);
throw;
}
}
static void Main(string[] args)
{
// 1. Create a new Simple Injector container
var container = new Container();
// 2. Configure the container (register)
container.Register<IMongoProvider, MongoProvider>(Lifestyle.Singleton);
container.Register<IInputProvider, MongoInputProvider>();
container.Register<IOutputProvider, MongoOutputProvider>();
container.Register<IParseProvider,ConsoleParseProvider>();
container.Register<IMathProvider, DefaultMathProviderProvider>();
// 3. Optionally verify the container's configuration.
container.Verify();
/*
var calc = new Calculator(
new MongoInputProvider(new MongoProvider("localhost:\\mongo")), //<===
new MongoOutputProvider(new MongoProvider("localhost:\\mongo")),//<===
new ConsoleParseProvider(),
new DefaultMathProviderProvider()
);
*/
var calc = container.GetInstance<Calculator>();
calc.MainLoop();
Console.ReadLine();
}
public TimedHostedService(SimpleInjector.Container container, Settings settings /*, ILogger logger*/)
{
this.container = container;
this.settings = settings;
//this.logger = logger;
this.timer = new Timer(callback: _ => this.DoWork());
}
private static void RegisterFallback <TService>(this Container container, Action <UnregisteredTypeEventArgs> register) =>
container.ResolveUnregisteredType += (_, args) =>
{
if (!args.Handled && args.UnregisteredServiceType == typeof(TService))
{
register(args);
}
};
public static SimpleInjector.Container Initialize()
{
_container = new SimpleInjector.Container();
_container.Options.DefaultScopedLifestyle = new WebRequestLifestyle();
Register();
return(_container);
}
public Container(SimpleInjector.Container container, bool child = false)
{
_container = container;
_child = child;
// No support for child containers, but the scoped lifestyle can kind of due to trick
AsyncScopedLifestyle.BeginScope(_container);
}
//public bool IsWebApp { get; }
public SimpleServiceContainer()
{
Container = new Container();
Container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
// Set to false. This will be the default in v5.x and going forward.
Container.Options.ResolveUnregisteredConcreteTypes = false;
}
public static Container RegisterComponents()
{
var container = new SimpleInjector.Container();
RegisterViewModels(container);
RegisterUseCases(container);
return(container);
}
private void ConfigureMvc(SimpleInjector.Container container)
{
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
System.Web.Mvc.DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
}
public static void RegisterPlugins <TImplements, TExport>(this Container container,
IEnumerable <Assembly> assemblies, Lifestyle lifestyle = null) where TExport : class
{
var pluginTypes = GetTypes <TImplements>(assemblies).ToArray();
HandleLifestyle <TExport>(container, lifestyle, pluginTypes);
container.RegisterAll <TExport>(pluginTypes);
}
private static void InitializeContainer(Container container)
{
BootStrapperApplication.RegisterServices(container);
BootStrapperDomain.RegisterServices(container);
BootStrapperInfra.RegisterServices(container);
container.Register <IUserStore <ApplicationUser> >();
}
public static void RegisterPlugins <T>(this Container container, IEnumerable <Assembly> assemblies,
Lifestyle lifestyle = null) where T : class
{
var pluginTypes = GetTypes <T>(assemblies).ToArray();
HandleLifestyle <T>(container, lifestyle, pluginTypes);
container.RegisterCollection <T>(pluginTypes);
}
public void Initialize()
{
messageContainer = new SimpleInjector.Container();
messageContainer.Register <NLog.ILogger, LoggingCommand>(Lifestyle.Singleton);
messageContainer.Register <IMessageProcessor <UasHeartbeat>, HeartbeatProcessor>(Lifestyle.Singleton);
messageContainer.Register <IMessageProcessor <UasBatteryStatus>, BatteryStatusProcessor>(Lifestyle.Singleton);
messageContainer.Register <IMessageProcessor <UasStatustext>, StatustextProcessor>(Lifestyle.Singleton);
}
public ValidatedBreezeContext(
ISession session,
IBreezeConfig breezeConfig,
IBreezeConfigurator breezeConfigurator,
IEventPublisher eventPublisher,
Container container) : base(breezeConfig, session, breezeConfigurator, eventPublisher)
{
_container = container;
}
public static Configure SimpleInjector(this Configure config, SimpleInjector.Container container)
{
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.Options.AllowOverridingRegistrations = true;
config.Container = new Internal.Container(container);
return(config);
}
public Container(SimpleInjector.Container container, bool child = false)
{
_container = container;
_child = child;
_namedCollections = new Dictionary <Type, List <SimpleInjector.Registration> >();
// No support for child containers, but the scoped lifestyle can kind of due to trick
AsyncScopedLifestyle.BeginScope(_container);
}
private static Container GetRegisteredContainer()
{
SimpleInjector.Container container = new SimpleInjector.Container();
container.Register <IDependencyOne, DependencyOne>();
container.Register <IDependencyTwo, DependencyTwo>();
container.Register <IDependencyThree, DependencyThree>();
container.Register <IProcessorFactory, ProcessorFactory>();
return(container);
}
public SimpleInjectorJobActivator(Injector.Container container)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
_container = container;
}
public void PerformTest()
{
var spCont = new SimpleInjector.Container();
spCont.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
spCont.Register <ICentralConfigProvider, TestConfigProvider>(Lifestyle.Scoped);
using (AsyncScopedLifestyle.BeginScope(spCont))
{
spCont.GetInstance <ICentralConfigProvider>();
}
var autofacBd = new Autofac.ContainerBuilder();
autofacBd.RegisterType <TestConfigProvider>().As <ICentralConfigProvider>();
var autofac = autofacBd.Build();
using (var scope = autofac.BeginLifetimeScope())
{
autofac.Resolve <ICentralConfigProvider>();
}
var count = 1000;
Console.WriteLine($"Start test {count} times: -----------------------");
//----SimpleInjector
var task = Task.Run(() => TestUtil.RunWatch("SimpleInjector", count, () =>
{
using (AsyncScopedLifestyle.BeginScope(spCont))
{
var siIns = spCont.GetInstance <ICentralConfigProvider>();
}
}));
//-------------------------------------------------
var task1 = Task.Run(() => TestUtil.RunWatch("Autofac", count, () =>
{
using (var scope = autofac.BeginLifetimeScope())
{
autofac.Resolve <ICentralConfigProvider>();
}
}));
//----SimpleInjector
/*var task = Task.Run(() => TestUtil.RunWatch("Castle", count, () =>
* {
* using (castle.BeginScope())
* {
* castle.Resolve<ICentralConfigProvider>();
* }
* }));*/
task.Wait();
task1.Wait();
}
private static void CriarContainerInjecaoDependencia()
{
container = new SimpleInjector.Container();
container.Register <IClienteRepositorio <Cliente>, ClienteRepositorio>(Lifestyle.Singleton);
container.Register <IContaCorrenteRepositorio <ContaCorrente>, ContaCorrenteRepositorio>(Lifestyle.Singleton);
container.Register <IContaEspecialRepositorio <ContaEspecial>, ContaEspecialRepositorio>(Lifestyle.Singleton);
container.Register <Form1>();
}
// Configure your AppHost with the necessary configuration and dependencies your App needs
public override void Configure(Funq.Container container)
{
base.SetConfig(new HostConfig
{
DebugMode = AppSettings.Get(nameof(HostConfig.DebugMode), false),
HandlerFactoryPath = "api"
});
// plugins
Plugins.Add(new TemplatePagesFeature());
Plugins.Add(new ValidationFeature());
SimpleContainer = new Container();
//SimpleContainer.Options.DefaultScopedLifestyle = ScopedLifestyle.Flowing;
container.Adapter = new SimpleInjectorIocAdapter(SimpleContainer);
InitializeCache();
InitializeDbConnectionFactory();
InitializeMessaging();
SimpleContainer.Register(() => Container.Adapter.Resolve <IMessageService>().MessageFactory);
SimpleContainer.Register <IMessageProducer>(() => Container.Adapter.Resolve <IMessageFactory>().CreateMessageProducer(), Lifestyle.Transient);
SimpleContainer.Register <IMessageQueueClient>(() => Container.Adapter.Resolve <IMessageFactory>().CreateMessageQueueClient(), Lifestyle.Transient);
InitializeIntegrations();
// repositories
SimpleContainer.Register <ILinkRepository, LinkRepository>();
SimpleContainer.Register <ITagRepository, TagRepository>();
// validators
SimpleContainer.Register <ITagValidator, TagValidator>();
SimpleContainer.Collection.Register(typeof(IValidator <>), this.ServiceAssemblies);
SimpleContainer.Collection.Register(typeof(ICreateLinkScreenshotHandler), this.ServiceAssemblies);
//SimpleContainer.RegisterDecorator(...); // https://cuttingedge.it/blogs/steven/pivot/entry.php?id=93
// events
SimpleContainer.RegisterInstance <IEventBus>(new DomainEventBus(SimpleContainer));
SimpleContainer.Collection.Register(typeof(IEventHandler <>), this.ServiceAssemblies);
// Done container registration!
SimpleContainer.Verify(VerificationOption.VerifyOnly);
OnConfigEnding();
// Messaging Service
var mqHost = Container.Adapter.Resolve <IMessageService>();
mqHost.RegisterHandler <CreateLinkScreenshotRequest>(base.ExecuteMessage);
mqHost.Start();
}
private static void InitializeContainer(SimpleInjector.Container container)
{
container.Options.DefaultScopedLifestyle = new ExecutionContextScopeLifestyle();
container.Register <ErpContext>(Lifestyle.Scoped);
container.Register(typeof(IUnitOfWork <>), typeof(UnitOfWork <>), Lifestyle.Scoped);
container.Register <ISorteioService, SorteioService>();
container.Register <IJogadorService, JogadorService>();
container.Register <IJogoService, JogoService>();
}
private static Container GetRegisteredContainer()
{
SimpleInjector.Container container = new SimpleInjector.Container();
container.Register <IDependencyOne, DependencyOne>();
container.Register <IDependencyTwo, DependencyTwo>();
container.Register <IDependencyThree, DependencyThree>();
container.Register <IProcessorFactory, ProcessorFactory>();
container.RegisterCollection <IProcessor>(new Assembly[] { Assembly.GetExecutingAssembly() });
return(container);
}
public Form1()
{
InitializeComponent();
CustomerContainer = new Container();
CustomerContainer
.Register <ICustomer, SqlCustomerData>(Lifestyle.Singleton);
CustomerContainer.Verify();
}
public WebApiDependencyResolver(Container container)
{
if (container == null)
throw new ArgumentNullException("container");
_container = container;
_provider = container;
}
static void Main(string[] args)
{
// Configure container
var container = new Container();
container.Register<IClock, Clock>();
// Top shelf setup
HostFactory.Run(
config =>
{
config.UseSimpleInjector(container);
config.UseLog4Net("log4net.xml");
config.Service<Clock>(
s =>
{
s.ConstructUsingSimpleInjector();
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
config.SetDescription("TopShelf Demo service");
config.SetDisplayName("TopShelf Demo");
config.SetServiceName("TopShelfDemo");
});
}