public void Activator()
{
var provider = _dependencies
.AddSingleton <ISession, Session>()
.BuildProvider();
var first = provider.GetService <ISession>();
var second = provider.GetService <ISession>();
Assert.Same(first, second);
}
public void Throw_Not_Generic_Implementation()
{
var builder = new DependencyCollection();
Assert.Throws <InvalidOperationException>(() =>
builder.AddSingleton(typeof(IRepository <>), typeof(FooRepository)));
}
public static DependencyCollection AddPool <T>(this DependencyCollection dependencies,
Func <IServiceProvider, T> builder, int capacity = 10)
where T : class
{
dependencies.AddSingleton <IPool <T> >(provider => new Pool <T>(capacity, () => builder(provider)));
return(dependencies);
}
public void Destroy()
{
var provider = _dependencies
.AddSingleton <IMapper <Boo>, CompiledMapper <Boo> >()
.AddSingleton <IBooRepository>(ctx => new BooRepository(ctx.GetService <IConfiguration>(), ctx.GetService <ISession>()))
.AddSingleton <BooService>()
.BuildProvider();
var repository = (BooRepository)provider.GetService <IBooRepository>();
var service = provider.GetService <BooService>();
provider.Dispose();
Assert.True(repository.Disposed);
Assert.True(service.Disposed);
}
public static DependencyCollection AddLogs(this DependencyCollection dependencies)
{
dependencies
.AddSingleton <IRenderersCollection, RenderersCollection>()
.AddFactory <ILogProvider, LogProvider>(factory => factory
.Lifetime(DependencyLifetime.Singleton)
.CreateIf <NullLogProvider>(engine => !engine.Contains(typeof(ILogWriter))))
.AddSingleton(typeof(ILogger <>), typeof(Logger <>))
.EnsureJsonEnabled();
return(dependencies);
}
public static DependencyCollection AddJson(this DependencyCollection dependencies,
CultureInfo?culture = null)
{
dependencies
.AddSingleton <JConverter>()
.AddDependency(
new[] { typeof(IConvertersCollection) },
provider => new ConvertersCollection(provider, culture),
DependencyLifetime.Singleton);
return(dependencies);
}
public static DependencyCollection AddServer(this DependencyCollection dependencies)
{
if (dependencies.Contains <HttpServer>())
{
return(dependencies);
}
dependencies
.AddSingleton <HttpServer>()
.AddSingleton <HttpRouter>();
return(dependencies);
}
public static DependencyCollection AddECS(this DependencyCollection dependencies)
{
dependencies
.AddSingleton <IEntityState, EntityState>();
//actors
dependencies
.AddFactory(new FilterFactory <IActorContext>(typeof(IActorFilter)))
.AddFactory(new GroupFactory <IActorContext>(typeof(IActorGroup)))
.AddFactory(new SingleFactory <IActorContext>(typeof(SingleActor <>)))
.AddInstance <IActorContext>(new ActorContext())
.AddSingleton <IActorFactory, ActorFactory>();
// assets
dependencies
.AddFactory(new FilterFactory <IAssetContext>(typeof(IAssetFilter)))
.AddFactory(new GroupFactory <IAssetContext>(typeof(IAssetGroup)))
.AddFactory(new SingleFactory <IAssetContext>(typeof(SingleAsset <>)))
.AddSingleton <IAssetContext, AssetContext>()
.AddSingleton <AssetFactory>();
// components
dependencies
.AddSingleton <IComponentFactory, ComponentFactory>();
// systems
dependencies
.AddFactory <ISystemService, SystemService>(systemService => systemService.DependedLifetime())
.AddFactory(new SystemPipelineFactory());
// source
dependencies
.AddInstance(new SourceDescriptions())
.AddSingleton(typeof(IEntitySourceContext <>), typeof(EntitySourceContext <>))
.EnsureJsonEnabled();
return(dependencies);
}
public void Two_Contracts()
{
var implementation = typeof(FooRepository);
var contracts = new[] { implementation, typeof(IRepository <Foo>) };
var provider = _dependencies
.AddSingleton <ISession, Session>()
.AddDependency(contracts, implementation, DependencyLifetime.Transient)
.BuildProvider();
var byImplementation = provider.GetRequiredService <FooRepository>();
var byInterface = provider.GetRequiredService <IRepository <Foo> >();
Assert.NotSame(byImplementation, byInterface);
Assert.IsType <FooRepository>(byInterface);
}
private static void AddSingleton(DependencyCollection dependencies, ServiceDescriptor descriptor)
{
if (descriptor.ImplementationInstance != null)
{
dependencies.AddInstance(descriptor.ServiceType, descriptor.ImplementationInstance);
}
else if (descriptor.ImplementationFactory == null)
{
dependencies.AddSingleton(descriptor.ServiceType, descriptor.ImplementationType);
}
else
{
var contracts = new[] { descriptor.ServiceType };
var resolver = BuildDelegateResolver(descriptor);
dependencies.Add(new SingletonDependency(contracts, resolver));
}
}
