public void ChildContainer_Dispose_Singleton_Correctly()
{
var container = new DependencyInjectionContainer();
container.Configure(c =>
{
c.Export <DisposableService>().As <IDisposableService>().Lifestyle.Singleton();
});
var disposedCalled = false;
using (var childContianer = container.CreateChildScope())
{
var disposable = childContianer.Locate <IDisposableService>();
Assert.NotNull(disposable);
disposable.Disposing += (sender, args) => disposedCalled = true;
}
Assert.False(disposedCalled);
container.Dispose();
Assert.True(disposedCalled);
}
public void Grace()
{
var container = new DependencyInjectionContainer(GraceDynamicMethod.Configuration());
container.Configure(c =>
{
foreach (var type in _types)
{
c.Export(type).As(type);
}
});
int length = 0;
if (Scenario == ResolveScenario.ResolveOne)
{
length = 1;
}
else if (Scenario == ResolveScenario.ResolveHalf)
{
length = _types.Length / 2;
}
else if (Scenario == ResolveScenario.ResolveAll)
{
length = _types.Length;
}
for (var i = 0; i < length; i++)
{
container.Locate(_types[i]);
}
container.Dispose();
}
public void DisposeDisposableObjectsByDefault()
{
var container = new DependencyInjectionContainer().Register <DisposableSpy>();
var disposableInstance = container.Resolve <DisposableSpy>();
container.Dispose();
disposableInstance.DisposeMustHaveBeenCalledExactlyOnce();
}
public void DisposableTransientTrack_TurnedOn_Export()
{
var container = new DependencyInjectionContainer();
container.Configure(c => c.Export <DisposableService>().As <IDisposableService>());
var disposableInstance = container.Locate <IDisposableService>();
var disposed = false;
disposableInstance.Disposing += (sender, args) => disposed = true;
container.Dispose();
Assert.True(disposed);
}
public void DisposableTransientTrack_TurnedOn_TransientLifestyle()
{
var container = new DependencyInjectionContainer();
container.Configure(c =>
{
c.Export(typeof(DependentService <>)).As(typeof(IDependentService <>));
c.Export <DisposableService>().As <IDisposableService>().Lifestyle.SingletonPerObjectGraph();
});
var instance = container.Locate <IDependentService <IDisposableService> >();
var disposed = false;
instance.Value.Disposing += (sender, args) => disposed = true;
container.Dispose();
Assert.True(disposed);
}
static async Task Main(string[] args)
{
var container = new DependencyInjectionContainer();
container.Configure(c =>
{
c.ExportAs <MessagePackClientSerializationTypeAttributor, IClientSerializationTypeAttributor>();
c.ProxyNamespace("https://localhost:5001/", serializer: new MessagePackClientSerializer(), namingConvention: new InterfaceNamingConvention(),
namespaces: "EasyRpc.Examples.SharedDefinitions");
});
var mathService = container.Locate <IMathService>();
var result = await mathService.Add(5, 10);
foreach (var provider in container.MissingExportStrategyProviders)
{
if (provider is IDisposable disposable)
{
disposable.Dispose();
}
}
container.Dispose();
}
public void Replace <I, T>()
{
_container.Dispose();
_container = ConfigureContainer(_configuration);
_container.Configure(c => c.Export <T>().As <I>());
}
public void Dispose()
{
_container?.Dispose();
}
public void CleanupDelegateTest()
{
DependencyInjectionContainer container = new DependencyInjectionContainer();
bool cleanupFired = false;
bool disposed = false;
container.Configure(
c => c.Export<DisposableService>().As<IDisposableService>().DisposalCleanupDelegate(x => cleanupFired = true));
IDisposableService disposableService = container.Locate<IDisposableService>();
disposableService.Disposing += (sender, args) => disposed = true;
container.Dispose();
Assert.True(cleanupFired);
Assert.True(disposed);
}
protected override void OnExit(ExitEventArgs e)
{
base.OnExit(e);
container.Dispose();
}
