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(); }