static void Main(string[] args)
{
var services = new ServiceContainer();
services.AddType <IFakeContextAccessor, FakeContextAccessor>(Lifetime.Singleton);
services.AddType <IFakeContextFactory, FakeContextFactory>(Lifetime.Singleton);
var resolver = services.Build();
var factory = resolver.Resolve <IFakeContextFactory>();
var currentContext = factory.Create();
var accessor = resolver.Resolve <IFakeContextAccessor>();
var context = accessor.FakeContext;
//currentContext == context应为true
Console.WriteLine(currentContext == context);
//context != null应为true
Console.WriteLine(context != null);
Console.ReadKey();
}
static void Main(string[] args)
{
//创建一个容器
IServiceContainer services = new ServiceContainer();
services.Configure(config =>
{
config.Interceptors.AddTyped <SampleInterceptor>();
});
services.AddType <ISampleService, SampleService>();
services.AddType <ISampleRepository, SampleRepository>();
//使用类型注册服务
services.AddType <ILogger, Logger>();
//使用实例注册服务，服务的生命周期限定为单例
services.AddInstance <ITaskService>(new TaskService());
//使用委托工厂注册服务
services.AddDelegate <ITaskService, TaskService>(resolver => new TaskService());
//创建服务解析器
IServiceResolver serviceResolver = services.Build();
//解析单个服务
ISampleService sampleService = serviceResolver.Resolve <ISampleService>();
//解析单个服务，并且验证是否为null，为null则抛出异常
ISampleService sampleServiceRequired = serviceResolver.ResolveRequired <ISampleService>();
//解析服务集合，如果未注册，则为空集合
IEnumerable <ISampleService> sampleServices = serviceResolver.ResolveMany <ISampleService>();
}
static void Main(string[] args)
{
//var target = new RegisterInput { Name = "lemon", Email = "*****@*****.**", Password = "******" };
//var validationResults = new List<ValidationResult>();
//var context = new ValidationContext(target, null, null);
//var isValid = Validator.TryValidateObject(target, context, validationResults, true);
var services = new ServiceContainer();
services.AddType <IAccountService, AccountService>();
services.AddDataAnnotations();
var serviceResolver = services.Build();
var accountService = serviceResolver.Resolve <IAccountService>();
accountService.Register(new RegisterInput {
Name = null, Email = null
});
accountService.Register(new RegisterInput {
Name = "lemon", Email = "lemon", Password = "******"
});
accountService.Register(new RegisterInput {
Name = "lemon", Email = "*****@*****.**", Password = "******"
});
accountService.Register(new RegisterInput {
Name = "lemon", Email = "*****@*****.**", Password = "******"
});
Console.ReadKey();
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddCors();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Star Wars Api", Version = "v1"
});
});
services.AddJwt();
var builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.AsImplementedInterfaces();
InfrastructureContainer.Build(builder, Configuration);
ServiceContainer.Build(builder);
builder.Populate(services);
Container = builder.Build();
return(new AutofacServiceProvider(Container));
}
static void Main(string[] args)
{
IServiceContainer services = new ServiceContainer();
services.AddType <IInternalLogger, ConsoleLogger>();
Action <ComponentOptions> componentOptions = component =>
{
component.AddLineProtocolCollector(options =>
{
options.Server = "http://localhost:8186";
options.Database = "aspectcore_apm";
});
component.AddApplicationProfiler(op => op.Interval = 1);
};
Action <ApplicationOptions> applicationOptions = options =>
{
options.ApplicationName = typeof(Program).Assembly.GetName().Name;
options.Environment = "Development";
};
services.AddAspectCoreAPM(componentOptions, applicationOptions);
var serviceResolver = services.Build();
var collectorLifetime = serviceResolver.Resolve <IComponentLifetime>();
collectorLifetime.Start();
Console.ReadKey();
collectorLifetime.Stop();
}
static IServiceResolver ContainerBuild()
{
IServiceContainer serviceContainer1 = new ServiceContainer();
serviceContainer1.AddAspectScope();
serviceContainer1.AddType <ILogger, ConsoleLogger>();
return(serviceContainer1.Build());
}
public void Interface_Proxy()
{
var serviceContainer = new ServiceContainer();
serviceContainer.AddType <IProxyTransient, ProxyTransient>();
var resolver = serviceContainer.Build();
var transient = resolver.Resolve <IProxyTransient>();
Assert.True(transient.IsProxy());
}
public void Class_Proxy()
{
var serviceContainer = new ServiceContainer();
ConfigureServiceInternal(serviceContainer);
var resolver = serviceContainer.Build();
var transient = resolver.Resolve <ProxyTransient>();
Assert.True(transient.IsProxy());
}
public void ImplementationMethodFromInjector_Test()
{
var container = new ServiceContainer();
container.AddType <IService, Service>();
var resolver = container.Build();
var service = resolver.Resolve <IService>();
var val = service.GetValue("le");
Assert.Equal("lemon", val);
}
public void Replace_IServiceProvider()
{
var services = new ServiceContainer();
services.Transients.AddType <IServiceProvider, ServiceProvider>();
var resolver = services.Build();
var serviceProvider = resolver.Resolve <IServiceProvider>();
Assert.NotEqual(resolver, serviceProvider);
Assert.IsType <ServiceProvider>(serviceProvider);
}
private static void Init()
{
var container = new ServiceContainer();
container.AddType <CustomService>();
container.AddType <ILogger, ConsoleLogger>();
container.AddType <ICustomService, CustomService>();
DependencyResolver.SetDependencyResolver(container.Build());
var interceptorCollection = new InterceptorCollection();
interceptorCollection.AddTyped <CustomInterceptorAttribute>();
}
public static void Main()
{
IServiceContainer services = new ServiceContainer();
services.AddType <ICanService, PeopleService>();
services.Configure(configure => {
configure.Interceptors.Add(new CustomInterceptorFactory());
});
var serviceResolver = services.Build();
var service = (ICanService)serviceResolver.GetService(typeof(ICanService));
service.CanSayHello("测试");
}
public void Resolve_RegisterEnumerable()
{
var services = new ServiceContainer();
services.Transients.AddType <IService, Transient>();
services.Singletons.AddType <IService, Singleton>();
services.Scopeds.AddType <IService, Scoped>();
services.Transients.AddDelegate <IEnumerable <IService> >(r => new IService[] { new Transient(), new Transient(), new Transient(), new Transient() });
var resolver = services.Build();
var enumerable = resolver.Resolve <IEnumerable <IService> >();
Assert.NotNull(enumerable);
Assert.Equal(4, enumerable.Count());
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
var builder = new ContainerBuilder();
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.AsImplementedInterfaces();
InfrastructureContainer.Build(builder);
ServiceContainer.Build(builder);
builder.Populate(services);
Container = builder.Build();
return(new AutofacServiceProvider(Container));
}
public Benckmarks()
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <Logger>().As <ILogger>().InstancePerDependency();
containerBuilder.RegisterType <TaskService>().As <ITaskService>().InstancePerDependency();
containerBuilder.RegisterType <SampleRepository>().As <ISampleRepository>().InstancePerDependency().PropertiesAutowired();
containerBuilder.RegisterType <SampleService2>().As <ISampleService>().InstancePerDependency();
container = containerBuilder.Build();
var serviceContainer = new ServiceContainer();
serviceContainer.AddType <ILogger, Logger>(Lifetime.Transient);
serviceContainer.AddType <ITaskService, TaskService>(Lifetime.Transient);
serviceContainer.AddType <ISampleRepository, SampleRepository>(Lifetime.Transient);
serviceContainer.AddType <ISampleService, SampleService2>(Lifetime.Transient);
serviceResolver = serviceContainer.Build();
}
static void Main1(string[] args)
{
IServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddAspectScope();
serviceContainer.AddType <IA, A>();
serviceContainer.AddType <IB, B>();
serviceContainer.AddType <IC, C>();
var r = serviceContainer.Build();
Task.WaitAll(
Task.Run(() => { r.CreateScope().Resolve <IA>().None(); }),
Task.Run(() => { r.CreateScope().Resolve <IB>().None(); }),
Task.Run(() => { r.CreateScope().Resolve <IC>().None(); }),
Task.Run(() => { r.CreateScope().Resolve <IA>().Nested(); }),
Task.Run(() => { r.CreateScope().Resolve <IB>().Nested(); }),
Task.Run(() => { r.CreateScope().Resolve <IC>().Nested(); }),
Task.Run(() => { r.CreateScope().Resolve <IA>().Aspect(); }),
Task.Run(() => { r.CreateScope().Resolve <IB>().Aspect(); }),
Task.Run(() => { r.CreateScope().Resolve <IC>().Aspect(); }));
IServiceContainer serviceContainer1 = new ServiceContainer();
serviceContainer1.AddAspectScope();
serviceContainer1.AddType <IA, A>();
serviceContainer1.AddType <IB, B>();
serviceContainer1.AddType <IC, C>();
Console.WriteLine();
var r1 = serviceContainer1.Build();
r1.Resolve <IA>().None();
r1.Resolve <IB>().None();
r1.Resolve <IC>().None();
r1.Resolve <IA>().Nested();
r1.Resolve <IB>().Nested();
r1.Resolve <IC>().Nested();
r1.Resolve <IA>().Aspect();
r1.Resolve <IB>().Aspect();
r1.Resolve <IC>().Aspect();
Console.ReadKey();
}
public void LoadBinding()
{
var dict = new Dictionary <string, string>
{
{ "creator:age", "24" },
{ "creator:name", "lemon" }
};
var builder = new ConfigurationBuilder().AddEnvironmentVariables();
builder.AddInMemoryCollection(dict);
var configuration = builder.Build();
var container = new ServiceContainer();
container.AddInstance <IConfiguration>(configuration);
container.AddConfigurationInject();
container.AddType <BindConfigService>();
var service = container.Build().Resolve <BindConfigService>();
Assert.Equal(service.ToString(), "lemon-24");
}
static void Main(string[] args)
{
IServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddAspectScope();
serviceContainer.AddType <IA, A>();
serviceContainer.AddType <IB, B>();
serviceContainer.AddType <IC, C>();
var r = serviceContainer.Build();
r.Resolve <IA>().None();
r.Resolve <IB>().None();
r.Resolve <IC>().None();
r.Resolve <IA>().Nested();
r.Resolve <IB>().Nested();
r.Resolve <IC>().Nested();
r.Resolve <IA>().Aspect();
r.Resolve <IB>().Aspect();
r.Resolve <IC>().Aspect();
Console.ReadKey();
}
public SimpleObjectBenchmarks()
{
var serviceContainer = new ServiceContainer();
serviceContainer.Transients.AddType <IUserService, UserService1>();
serviceContainer.Transients.AddType <IUserService, UserService2>();
serviceContainer.Transients.AddType <IUserService, UserService>();
serviceContainer.Transients.AddType(typeof(IRepository <>), typeof(Repository <>));
serviceResolver = serviceContainer.Build();
var serviceCollection = new ServiceCollection();
serviceCollection.AddTransient <IUserService, UserService1>();
serviceCollection.AddTransient <IUserService, UserService2>();
serviceCollection.AddTransient <IUserService, UserService>();
serviceCollection.AddTransient(typeof(IRepository <>), typeof(Repository <>));
serviceProvider = serviceCollection.BuildServiceProvider();
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType <UserService1>().As <IUserService>().InstancePerDependency();
containerBuilder.RegisterType <UserService2>().As <IUserService>().InstancePerDependency();
containerBuilder.RegisterGeneric(typeof(Repository <>)).As(typeof(IRepository <>));
containerBuilder.RegisterType <UserService>().As <IUserService>().InstancePerDependency();
autofacContainer = containerBuilder.Build();
zkWebContainer = new ZKWebContainer();
zkWebContainer.Register <IUserService, UserService1>(ReuseType.Transient, null);
zkWebContainer.Register <IUserService, UserService2>(ReuseType.Transient, null);
zkWebContainer.Register <IUserService, UserService>(ReuseType.Transient, null);
zkWebContainer.Register(typeof(IRepository <>), typeof(Repository <>), ReuseType.Transient, null);
dryIocContainer = new DryIocContainer();
dryIocContainer.Register <IUserService, UserService1>();
dryIocContainer.Register <IUserService, UserService2>();
dryIocContainer.Register <IUserService, UserService>();
dryIocContainer.Register(typeof(IRepository <>), typeof(Repository <>));
}
