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>();
}
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>();
}
static void Main(string[] args)
{
var serviceContaniner = new ServiceContainer();
serviceContaniner.AddType <ITaskService, TaskService>();
var containerBuilder = new ContainerBuilder();
//调用Populate扩展方法在Autofac中注册已经注册到ServiceContainer中的服务（如果有）。注：此方法调用应在RegisterDynamicProxy之前
containerBuilder.Populate(serviceContaniner);
var configuration = serviceContaniner.Configuration;
//调用RegisterDynamicProxy扩展方法在Autofac中注册动态代理服务和动态代理配置
containerBuilder.RegisterDynamicProxy(configuration, config =>
{
config.Interceptors.AddTyped <MethodExecuteLoggerInterceptor>(Predicates.ForService("*Service"));
});
var container = containerBuilder.Build();
var taskService = container.Resolve <ITaskService>();
taskService.Run();
}
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();
}
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();
}
public Test()
{
ioc = new ServiceDefintions()
.AddSingleton <IInterceptorConfiguration>(i =>
{
var c = new InterceptorConfiguration();
//c.Interceptors.Add(new TestInterceptor());
return(c);
})
.AddTransient <IInterceptorConfigurationHandler>(i =>
{
return(new InterceptorAttributeConfigurationHandler(null));
})
.AddTransient <IInterceptorCreatorFactory, InterceptorCreatorFactory>()
.AddSingleton <IInterceptDelegateBuilder>(i =>
{
return(i.GetRequiredService <IInterceptorCreatorFactory>().Build());
})
.AddTransient <ISyncFunc, SyncFunc>()
.AddTransient <ISyncFunc2, SyncFunc2>()
.BuildServiceProvider();
real = ioc.GetRequiredService <ISyncFunc2>();
real.SyncCallNoParameters();
proxy = ioc.GetRequiredService <ISyncFunc>();
proxy.SyncCallNoParameters();
var containerBuilder = new ServiceContainer();
aspectcoreIoc = containerBuilder.AddType <ISyncFunc2, SyncFunc2>(AspectCore.Injector.Lifetime.Transient)
.Build();
aspectcoreProxy = aspectcoreIoc.GetRequiredService <ISyncFunc2>();
aspectcoreProxy.SyncCallNoParameters();
}
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 IServiceResolver ContainerBuild()
{
IServiceContainer serviceContainer1 = new ServiceContainer();
serviceContainer1.AddAspectScope();
serviceContainer1.AddType <ILogger, ConsoleLogger>();
return(serviceContainer1.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 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 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);
}
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 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 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");
}
