private static void BenchStructureMap()
{
var services = new ServiceCollection();
services.AddScoped <IValueProvider, ValueProvider>();
services.AddLogging();
var container = new StructureMap.Container();
container.Configure(config =>
{
config.Scan(_ =>
{
_.AssemblyContainingType(typeof(Program));
_.WithDefaultConventions();
});
config.Populate(services);
});
Launch("StructureMap", (i) =>
{
var valueProvider = container.GetInstance <IValueProvider>();
valueProvider.GetValue(i);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddCors(c =>
{
c.AddPolicy("AllowOrigin", options => options.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});
services.AddTransient <IMessageBuilder <TodoItem, TodoItemResponse>, TodoItemResponseBuilder>();
services.AddTransient <ITodoItemsManager, TodoItemsManager>();
services.AddTransient <ITodoItemsDao, TodoItemsDao>();
services.AddDbContext <TodoContext>(opt =>
{ opt.UseSqlServer(Configuration.GetConnectionString("TodoDb")); });
services.AddMvc();
// Wire up StructureMap
var container = new Container();
container.Configure(config =>
{
config.Populate(services);
config.For <IServiceLocator>().Singleton().Use(new StructureMapServiceLocator(container));
});
var registrar = new StructureMapRegistrar(container);
registrar.Register <BaseRegistry>();
return(new StructureMapServiceProvider(container));
}
public static ContainerBuilderOptions <TTenant> WithStructureMapServiceCollection <TTenant>(this ContainerBuilderOptions <TTenant> options,
Action <TTenant, IServiceCollection> configureTenant)
where TTenant : class
{
// Set a func, that is only invoked when the ServiceProvider is required. This ensures it runs after all other configuration methods
// which is important as other methods can still add new services to the servicecollection after this one is invoked and we
// dont want them to be missed when populating the container.
options.Builder.BuildServiceProvider = new Func <IServiceProvider>(() =>
{
var container = new StructureMap.Container();
container.Populate(options.Builder.Services);
container.Configure(_ =>
_.For <ITenantContainerBuilder <TTenant> >()
.Use(new StructureMapTenantContainerBuilder <TTenant>(container, (tenant, configurationExpression) =>
{
var tenantServices = new ServiceCollection();
configureTenant(tenant, tenantServices);
configurationExpression.Populate(tenantServices);
}))
);
// now configure nested container per tenant.
return(container.GetInstance <IServiceProvider>());
});
return(options);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddCors(c =>
{
c.AddPolicy("AllowOrigin", options => options.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});
services.AddTransient <IMessageBuilder <VirtualCloset, VirtualClosetResponse>, VirtualClosetResponseBuilder>();
services.AddTransient <IVirtualClosetDao, VirtualClosetDao>();
services.AddTransient <ICategoryManager, CategoryManager>();
services.AddTransient <IVirtualClosetManager, VirtualClosetManager>();
services.AddDbContext <VirtualClosetContext>(opt =>
{
opt.UseSqlServer(Configuration.GetConnectionString("VirtualClosetDb"));
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
var container = new Container();
container.Configure(config =>
{
config.Populate(services);
config.For <IServiceLocator>().Singleton().Use(new StructureMapServiceLocator(container));
});
var registrar = new StructureMapRegistrar(container);
registrar.Register <BaseRegistry>();
return(new StructureMapServiceProvider(container));
}
public async Task Options_Configure_Child_Resolve_Child_Using_TenantContainerAdaptor()
{
ServiceCollection services = new ServiceCollection();
services.AddLogging();
// ServiceProvider serviceProvider = services.BuildServiceProvider();
StructureMap.Container container = new StructureMap.Container();
Dotnettency.Container.StructureMap.ContainerExtensions.Populate(container, services);
var adaptedContainer = container.GetInstance <ITenantContainerAdaptor>();
var containerEventsPublisher = container.TryGetInstance <ITenantContainerEventsPublisher <MyTenant> >();
container.Configure(_ =>
_.For <ITenantContainerBuilder <MyTenant> >()
.Use(new TenantContainerBuilder <MyTenant>(services, adaptedContainer, (s, t) => {
t.AddOptions();
t.Configure <MyOptions>((a) =>
{
a.Prop = true;
});
}, containerEventsPublisher))
);
// container.Populate(services);
var tenantContainerBuilder = adaptedContainer.GetRequiredService <ITenantContainerBuilder <MyTenant> >();
var tenantContainer = await tenantContainerBuilder.BuildAsync(new MyTenant());
IOptions <MyOptions> options = tenantContainer.GetRequiredService <IOptions <MyOptions> >();
Assert.True(options.Value?.Prop);
}
public void HttpClient()
{
var services = new ServiceCollection();
services.AddHttpClient("client")
.AddHttpMessageHandler <RequestContentMd5Handler>()
.AddHttpMessageHandler <HmacSigningHandler>();
var container = new StructureMap.Container();
container.Configure(config =>
{
config.For <ISecretRepository>().Singleton().Use(new SecretStore());
config.For <ISignatureCalculator>().Use <HmacSignatureCalculator>();
config.For <IMessageRepresentationBuilder>().Use <HmacMessageRepresentationBuilder>();
config.For <RequestContentMd5Handler>().Use <RequestContentMd5Handler>();
config.For <HmacSigningHandler>().Use <HmacSigningHandler>();
config.Populate(services);
});
var serviceProvider = container.GetInstance <IServiceProvider>();
var factory = serviceProvider.GetService <IHttpClientFactory>();
factory.CreateClient("client");
}
public static AdaptedContainerBuilderOptions <TTenant> WithStructureMap <TTenant>(this ContainerBuilderOptions <TTenant> options,
Action <TTenant, IServiceCollection> configureTenant)
where TTenant : class
{
var adaptorFactory = new Func <ITenantContainerAdaptor>(() =>
{
// host level container.
var container = new StructureMap.Container();
container.Populate(options.Builder.Services);
var adaptedContainer = container.GetInstance <ITenantContainerAdaptor>();
// add ITenantContainerBuilder<TTenant> service to the host container
// This service can be used to build a child container (adaptor) for a particular tenant, when required.
container.Configure(_ =>
_.For <ITenantContainerBuilder <TTenant> >()
.Use(new TenantContainerBuilder <TTenant>(adaptedContainer, configureTenant))
);
var adaptor = container.GetInstance <ITenantContainerAdaptor>();
return(adaptor);
});
var adapted = new AdaptedContainerBuilderOptions <TTenant>(options, adaptorFactory);
options.Builder.Services.TryAddScoped((_) => adapted);
return(adapted);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("DefaultConnection_" + Helper.GetPlatform().ToString())));
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
// Add application services.
services.AddTransient <IEmailSender, EmailSender>();
services.AddMvc();
services.AddMvc().AddControllersAsServices();
services.AddMvc()
.AddSessionStateTempDataProvider()
.AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
options.SerializerSettings.Converters.Add(new StringEnumConverter());
});
services.AddSession();
var z = new Registry();
z.Scan(x =>
{
x.TheCallingAssembly();
x.Assembly("As.A4ACore");
x.Assembly("As.Email");
x.SingleImplementationsOfInterface();
x.WithDefaultConventions();
});
var container = new StructureMap.Container();
services.AddSingleton <Container>(container);
container.Configure(config =>
{
config.Populate(services);
config.AddRegistry(z);
config.ForConcreteType <A4ARepository>().Configure.Ctor <string>("connectionString").Is(Configuration.GetConnectionString("MainLogic_" + Helper.GetPlatform().ToString()));
});
var loggerAdapter = container.GetInstance <A4ALogger>();
L.SetExternalLogger(loggerAdapter, AsLogInfo.Info);
return(container.GetInstance <IServiceProvider>());
}
public void Should_Remember_How_To_Work_With_SM()
{
using (StructureMap.Container container = new StructureMap.Container())
{
container.Configure(c =>
{
c.For<ILatLong>().Add<LatLong>();
});
Console.WriteLine(container.GetInstance<ILatLong>().GetType().Name);
}
}
static StructureMapSingletonUseCase()
{
container = new StructureMap.Container();
container.Configure(
x => x.For <IWebService>()
.Use <WebService>());
container.Configure(
x => x.For <IAuthenticator>().Singleton()
.Use <Authenticator>());
container.Configure(
x => x.For <IStockQuote>().Singleton()
.Use <StockQuote>());
container.Configure(
x => x.For <IDatabase>().Singleton()
.Use <Database>());
container.Configure(
x => x.For <IErrorHandler>().Singleton()
.Use <ErrorHandler>());
container.Configure(
x => x.For <ILogger>().Singleton()
.Use(c => new Logger()));
}
private IServiceProvider ConfigStructureMapDI(IServiceCollection services)
{
var container = new StructureMap.Container();
container.Configure(config =>
{
config.For <IRequestIdFactory>().Use <RequestIdFactory>().Singleton();
config.For <IRequestId>().Use <RequestId>().ContainerScoped();
config.Populate(services);
});
return(container.GetInstance <IServiceProvider>());
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc().AddControllersAsServices();
var container = new StructureMap.Container();
container.Configure(config =>
{
config.Populate(services);
});
As.Client.InitializeClient.StartupAndRegisterClientServices(Configuration, container);
return(container.GetInstance <IServiceProvider>());
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static IContainer Initialize()
{
var container = new StructureMap.Container();
container.Configure(cfg =>
{
cfg.Scan(s =>
{
s.WithDefaultConventions();
s.Assembly(Assembly.GetAssembly(typeof(BaseOperation<,>)));
s.Assembly(Assembly.GetAssembly(typeof(BaseService<>)));
});
cfg.For<IKarinUnitOfWork>().Use<KarinContext>();
});
return container;
//new Container(c => c.AddRegistry<DefaultRegistry>());
}
private IServiceProvider ConfigureIoc(IServiceCollection services)
{
var container = new StructureMap.Container();
container.Configure(config =>
{
config.Scan(scanner =>
{
scanner.AssemblyContainingType(typeof(Startup));
scanner.WithDefaultConventions();
});
config.Populate(services);
});
return(container.GetInstance <IServiceProvider>());
}
public static IContainer Initialize()
{
var container = new StructureMap.Container();
container.Configure(cfg =>
{
cfg.Scan(s =>
{
s.WithDefaultConventions();
s.Assembly(Assembly.GetAssembly(typeof(BaseOperation <,>)));
s.Assembly(Assembly.GetAssembly(typeof(BaseService <>)));
});
cfg.For <IFiberUnitOfWork>().Use <FiberContext>();
});
return(container);
//new Container(c => c.AddRegistry<DefaultRegistry>());
}
public void Options_Configure_Root_Resolve_Root()
{
// ServiceProvider serviceProvider = services.BuildServiceProvider();
StructureMap.Container container = new StructureMap.Container();
container.Configure((a) => {
ServiceCollection services = new ServiceCollection();
services.AddOptions();
services.Configure <MyOptions>((b) =>
{
b.Prop = true;
});
a.Populate(services);
});
// container.Populate(services);
IServiceProvider sp = container.GetInstance <IServiceProvider>();
IOptions <MyOptions> options = sp.GetRequiredService <IOptions <MyOptions> >();
Assert.True(options.Value?.Prop);
}
private IServiceProvider ConfigureStructureMap(IServiceCollection services)
{
var container = new StructureMap.Container();
container.Configure(config =>
{
// Register stuff in container, using the StructureMap APIs...
config.Scan(_ =>
{
// Automatically register services that follow default conventions, e.g.
// PurchasingService/IPurchasingService
// ConcreteService (concrete types can always be resolved)
// Typically, you will have a lot of Service/IService pairs in your app
_.AssemblyContainingType(typeof(Startup));
_.WithDefaultConventions();
// Register all of the implementations of IGamingService
// CrosswordService
// SudokuService
_.AddAllTypesOf <IGamingService>();
// Register all non-generic implementations of IValidatior<T> (UserModelValidator)
_.ConnectImplementationsToTypesClosing(typeof(IValidator <>));
});
// When a ILeaderboard<T> is requested, use Leaderboard<T>
config.For(typeof(ILeaderboard <>)).Use(typeof(Leaderboard <>));
// When an IUnitOfWork<T> is requested, run the lambda
// Also, has a "scoped" lifetime, instead of the default "transient" lifetime
config.For <IUnitOfWork>().Use(_ => new UnitOfWork(3)).ContainerScoped();
// For a given T, when an IValidator<T> is requested,
// but there are no non-generic implementations of IValidator<T>
// Use DefaultValidator<T> instead
config.For(typeof(IValidator <>)).Add(typeof(DefaultValidator <>));
//Populate the container using the service collection
config.Populate(services);
});
//Return the IServiceProvider. This tells ASP.NET Core to use StructureMap to resolve dependencies
return(container.GetInstance <IServiceProvider>());
}
public IServiceProvider ConfigureIoC(IServiceCollection services)
{
var container = new StructureMap.Container();
container.Configure(config =>
{
// Register stuff in container, using the StructureMap APIs...
config.Scan(_ =>
{
_.AssemblyContainingType(typeof(Startup));
_.WithDefaultConventions();
_.AddAllTypesOf <IPhotoService>();
_.AddAllTypesOf <IAlbumService>();
});
services.AddScoped <IPhotoService, PhotoService>();
services.AddScoped <IAlbumService, AlbumService>();
services.Add(ServiceDescriptor.Transient(typeof(IRepository <>), typeof(Repository <>)));
//Populate the container using the service collection
config.Populate(services);
});
return(container.GetInstance <IServiceProvider>());
}
private static void ConfigureServices(IServiceCollection services)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
services
.AddLogging(configure => configure.AddSerilog());
// add StructureMap
var container = new StructureMap.Container();
container.Configure(config =>
{
// Register stuff in container, using the StructureMap APIs...
config.Scan(_ =>
{
_.AssemblyContainingType(typeof(Program));
_.WithDefaultConventions();
});
// Populate the container using the service collection
config.Populate(services);
});
}
public static void Main(string[] args)
{
LogConfig.Init();
// add the framework services
var services = new ServiceCollection();
services.AddSingleton <IMapperFactory, TriviaMapperFactory>();
// add StructureMap
var container = new StructureMap.Container();
container.Configure(config =>
{
// Register stuff in container, using the StructureMap APIs...
config.Scan(_ =>
{
_.AssemblyContainingType(typeof(Program));
_.WithDefaultConventions();
});
// Populate the container using the service collection
config.Populate(services);
});
var serviceProvider = container.GetInstance <IServiceProvider>();
Application.Init();
var operativeServices = serviceProvider.GetService <IOperativeServices>();
var backOfficeServices = serviceProvider.GetService <IBackOfficeServices>();
TriviaApp triviaApp = new TriviaApp(operativeServices, backOfficeServices);
LogInDialog logInDialog = new LogInDialog(triviaApp);
logInDialog.Show();
Application.Run();
}
public void RegisterFactory <TResult>(Func <TResult> factory, RegistrationMode mode, RegistrationLifestyle lifestyle) where TResult : class
{
var lifecycle = GetLifecycle(lifestyle);
_container.Configure(r => r.For <TResult>(lifecycle).Use(() => factory()));
}
static void Main(string[] args)
{
// REGISTRATION
var container = new Container();
// Register MasterCard conrete type to ICreditCard
container.Configure(x => x.For <ICreditCard>().Use <MasterCard>());
// Shopper class has ICreditCard in it's constructor
// IoC will automatically get concrete type to MasterCard
var shopper = container.GetInstance <Shopper>();
shopper.Charge();
// LIFECYCLE
// Default lifecycle is "PerRequest"
// Specify your own this way
container.Configure(x => x.For <ICreditCard>().LifecycleIs(new SingletonLifecycle()));
// FEATURES
// TryGet => see if available => returns null if ICreditCard is NOT registered
container.TryGetInstance <ICreditCard>();
// Debugging => will show you what you have in container
Console.WriteLine(container.WhatDoIHave());
sContainer = new Container();
sContainer.Configure(x => x.For <ICreditCard>().Use <MasterCard>());
// Put registration into one registry class
container = new Container(new MyRegistry());
// Testing named instance
var classA = container.GetInstance <ClassA>();
var classB = container.GetInstance <ClassB>();
//var c = new StructureMap.Container(ce =>
//{
// ce.ForRequestedType<ICreditCard>().TheDefaultIsConcreteType<VisaCard>();
//});
//var test = c.GetInstance<ICreditCard>();
//var mock = new Mock<Container>();
//var t1 = mock.Setup(x => x.GetInstance<ICreditCard>()).Returns(new VisaCard());
//IoC.Initialize();
//var ccc = IoC.container.GetInstance<ICreditCard>();
var mock = new Mock <IContainer>();
var tt = mock.Object;
mock.Setup(x => x.GetInstance <ICreditCard>()).Returns(new MasterCard());
//var tt2 = mock.Object.GetInstance<ICreditCard>();
var worker = new Worker();
worker.Work(mock.Object);
var m = new Mock <HttpContextBase>();
//var t2 = m.Setup(x => x.Request).Returns();
}
public Container()
{
_container = new StructureMap.Container();
_container.Configure(x => x.For <IObjectFactory>().Use(this));
}
private static IContainer InitContainer()
{
RRTracer.Trace("Initializing container");
var initContainer = new StructureMap.Container();
initContainer.Configure(x =>
{
x.For<IResourceType>().OnCreationForAll((c, r) =>
{
if (!r.FileName.Contains("RequestReduce"))
throw new System.InvalidOperationException ("ResourceType file names must contain the string 'RequestReduce'");
});
x.For<IReducingQueue>().Singleton().Use<ReducingQueue>();
x.For<IReductionRepository>().Singleton().Use<ReductionRepository>();
x.For<IWuQuantizer>().Singleton().Use<WuQuantizer>();
x.For<LocalDiskStore>().Singleton();
x.For<DbDiskCache>().Singleton();
x.For<SqlServerStore>().LifecycleIs(new RRHybridLifecycle()).Use<SqlServerStore>().
Ctor<IStore>().Is(y => y.GetInstance<DbDiskCache>());
x.For<IFileRepository>().Use<FileRepository>();
x.For<IStore>().Use(y =>
{
switch (
y.GetInstance<IRRConfiguration>().
ContentStore)
{
case
Configuration.Store.
SqlServerStore:
return
y.GetInstance
<SqlServerStore>();
case
Configuration.Store.
LocalDiskStore:
default:
return
y.GetInstance
<LocalDiskStore>();
}
});
x.For<HttpContextBase>().Use(() => HttpContext.Current == null ? null : new HttpContextWrapper(HttpContext.Current));
});
initContainer.Configure(x => x.Scan(y =>
{
y.Assembly("RequestReduce");
y.ExcludeNamespace("RequestReduce.Utilities");
y.ExcludeNamespace("RequestReduce.Configuration");
y.ExcludeNamespace("RequestReduce.Store");
y.ExcludeNamespace("RequestReduce.ResourceTypes");
y.ExcludeType<IReductionRepository>();
y.ExcludeType<IReducingQueue>();
y.AddAllTypesOf<IReducer>();
y.WithDefaultConventions();
}
));
initContainer.Configure(x => x.Scan(y =>
{
y.Assembly("RequestReduce");
y.IncludeNamespace("RequestReduce.Utilities");
y.IncludeNamespace("RequestReduce.Configuration");
y.IncludeNamespace("RequestReduce.ResourceTypes");
y.AddAllTypesOf<IResourceType>();
y.With(new SingletonConvention());
}
));
initContainer.Configure(
x =>
x.For<AbstractFilter>().Use(
y =>
HttpContext.Current == null
? new ResponseFilter(null, Encoding.UTF8, y.GetInstance<IResponseTransformer>())
: new ResponseFilter(HttpContext.Current.Response.Filter, HttpContext.Current.Response.ContentEncoding, y.GetInstance<IResponseTransformer>())));
return initContainer;
}
public void Configure(Action <ConfigurationExpression> configuration)
{
_container.Configure(configuration);
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton<IConfigurationRoot>(Configuration);
services.Configure<AppSettings>(Configuration.GetSection("Application"));
var appSettings = Configuration.Get<AppSettings>("Application");
// Add framework services.
services.AddMvc();
//services.AddDistributedMemoryCache(); // Adds a default in-memory implementation of IDistributedCache
// Using Redis as Memory cache
services.AddDistributedRedisCache(options =>
{
options.Configuration = appSettings.Redis.Url;
options.InstanceName = appSettings.Redis.InstanceName;
options.ResolveDns();
});
services.AddSession();
services.AddSignalR();
// Predefine set of policies
services.AddAuthorization(options =>
{
options.AddPolicy("ADMIN", policy => {
policy.RequireClaim("admin");
});
options.AddPolicy("READ", policy => {
policy.RequireClaim("read");
});
options.AddPolicy("WRITE", policy => {
policy.RequireClaim("write");
});
options.AddPolicy("GET", policy => {
policy.RequireClaim("get");
});
options.AddPolicy("POST", policy => {
policy.RequireClaim("post");
});
options.AddPolicy("DELETE", policy => {
policy.RequireClaim("delete");
});
});
// Add Authentication services.
services.AddAuthentication(sharedOptions => sharedOptions.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme);
// Initialize container
container = new Container();
container.Configure(c =>
{
Serilog.ILogger appLogger = new LoggerConfiguration()
.WriteTo.Logzio(appSettings.LogzIO.AuthToken,
application: appSettings.LogzIO.Application,
reporterType: appSettings.LogzIO.ReporterType,
environment: appSettings.LogzIO.Environment)
.CreateLogger();
c.For<IApplicationContext>().Use<HttpAPIContext>();
c.ForSingletonOf<AppSettings>().Use(appSettings);
c.ForSingletonOf<Serilog.ILogger>().Use(appLogger);
});
services.InitializeAutoMapper();
// Resolve container
DependencyResolver.RegisterResolver(new StructureMapIOCContainer(container)).RegisterImplmentation();
container.Populate(services);
return container.GetInstance<IServiceProvider>();
}
