public void DefinesNamedScope_ExportGeneric()
{
var container = new DependencyInjectionContainer();
var disposed = false;
container.Configure(c =>
{
c.ExportFactory <IExportLocatorScope, IDisposableService>(scope =>
{
Assert.Equal("CustomScope", scope.ScopeName);
var service = new DisposableService();
service.Disposing += (o, e) => disposed = true;
return(service);
});
c.Export(typeof(GenericDependentClass <>)).ExternallyOwned().DefinesNamedScope("CustomScope");
});
Assert.False(disposed);
var instance = container.Locate <GenericDependentClass <IDisposableService> >();
Assert.NotNull(instance);
instance.Dispose();
Assert.True(disposed);
}
protected virtual void Dispose(bool Disposing)
{
if (Disposing && Service is IDisposable DisposableService)
{
DisposableService.Dispose();
}
}
private static IList <ImportFileDto> GetImportFilesFromDatabase()
{
try
{
var files = new List <ImportFileDto>();
return(DisposableService.Using(() => new SqlConnection(cs.GetDbConnStr()), connection =>
{
return DisposableService.Using(() => new SqlCommand("dbo.uspGetImportFile", connection),
sqlCommand =>
{
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.CommandTimeout = 900;
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
return DisposableService.Using(sqlCommand.ExecuteReader, reader =>
{
var importFileIdOrdinal = reader.GetOrdinal("ImportFileID");
var fileNameOrdinal = reader.GetOrdinal("FileName");
var fileExtensionOrdinal = reader.GetOrdinal("FileExtension");
var fileSizeOrdinal = reader.GetOrdinal("FileSize");
var fileTypeOrdinal = reader.GetOrdinal("FileType");
var processedOrdinal = reader.GetOrdinal("Processed");
var createdOnLocalOrdinal = reader.GetOrdinal("CreatedOnLocal");
while (reader.Read())
{
var file = new ImportFileDto
{
ImportFileId = reader.GetInt32(importFileIdOrdinal),
FileName = reader.GetString(fileNameOrdinal),
FileSize = reader.GetString(fileSizeOrdinal),
FileType = reader.GetString(fileTypeOrdinal),
Processed = reader.GetBoolean(processedOrdinal),
CreatedOn = !reader.IsDBNull(createdOnLocalOrdinal) ? reader.GetDateTime(createdOnLocalOrdinal) : DateTime.Now
};
if (!reader.IsDBNull(fileExtensionOrdinal))
{
file.FileExtension = reader.GetString(fileExtensionOrdinal);
}
if (file.FileType == c.LakerFileTypeName || file.FileType == c.EnvisionFileTypeName)
{
files.Add(file);
}
}
var retList = files.ToList();
return retList;
});
});
}));
}
catch (Exception ex)
{
Logger.Error(ex);
throw;
}
}
public void When_registering_external_instance_and_disposing_container_Then_instance_should_be_disposed()
{
var container = new Container();
var service = new DisposableService();
container.RegisterInstance <IService>(service);
container.Dispose();
Assert.That(service.IsDisposed, Is.True);
}
public void InstanceShouldNotBeDisposed()
{
var ioc = new ServiceContainer();
// DisposalPolicy.Manual
var disposableService = new DisposableService();
ioc.Register(typeof(IService1), "Token", disposableService);
ioc.Dispose();
Assert.IsFalse(disposableService.Disposed);
}
public void DisposalScope_ThrowExceptionDuringCleanUp()
{
var disposalScope = new DisposalScope();
var disposableService = new DisposableService();
var eventFired = false;
disposableService.Disposing += (sender, args) => eventFired = true;
disposalScope.AddDisposable(disposableService, disposed => { throw new Exception(); });
Assert.ThrowsAny <AggregateException>(() => disposalScope.Dispose());
}
public void ServicesRegisteredByInstanceShouldBeUntracked()
{
var svc = new DisposableService();
var registry = new Registry().Define <DisposableService>().As(svc);
using (var container = registry.CreateContainer()) {
var svc2 = container.GetService <DisposableService>();
Assert.Same(svc, svc2);
}
Assert.False(svc.Disposed);
}
public void ServicesRegisteredByInstanceShouldBeUntracked()
{
var svc = new DisposableService();
using (var container = Configuration.CreateContainer
(module => module.Define <DisposableService>().As(svc))
) {
var svc2 = container.GetService <DisposableService>();
Assert.Same(svc, svc2);
}
Assert.False(svc.Disposed);
}
public void Registering_instance_as_weak_reference_will_prevent_the_disposal()
{
var container = new Container();
var instance = new DisposableService();
container.RegisterInstance(instance, setup: Setup.With(weaklyReferenced: true));
instance = container.Resolve <DisposableService>();
container.Dispose();
Assert.IsFalse(instance.IsDisposed);
GC.KeepAlive(instance);
}
public void TestSingletonInstance()
{
ServiceCollection services = new ServiceCollection();
services.AddSingleton <DisposableService>();
IServiceProvider serviceProvider = services.BuildServiceProvider();
DisposableService service1 = serviceProvider.GetService <DisposableService>();
DisposableService service2 = serviceProvider.GetService <DisposableService>();
Assert.IsNotNull(service1);
Assert.AreSame(service1, service2);
}
public void TestTransientInstances()
{
ServiceCollection services = new ServiceCollection();
services.AddTransient <DisposableService>();
IServiceProvider serviceProvider = services.BuildServiceProvider();
DisposableService service1 = serviceProvider.GetService <DisposableService>();
DisposableService service2 = serviceProvider.GetService <DisposableService>();
Assert.IsNotNull(service1);
Assert.AreNotSame(service1, service2);
}
public void DisposalScope_DisposeCalledTest()
{
var disposalScope = new DisposalScope();
var disposableService = new DisposableService();
var eventFired = false;
disposableService.Disposing += (sender, args) => eventFired = true;
disposalScope.AddDisposable(disposableService);
disposalScope.Dispose();
Assert.True(eventFired);
}
public void ServiceProviderDisposedOnBuildException()
{
var service = new DisposableService();
var hostBuilder = new WebHostBuilder()
.UseServer(new TestServer())
.ConfigureServices(services =>
{
// Added as a factory since instances are never disposed by the container
services.AddSingleton(sp => service);
})
.UseStartup <StartupWithResolvedDisposableThatThrows>();
Assert.Throws <InvalidOperationException>(() => hostBuilder.Build());
Assert.True(service.Disposed);
}
private static IList <SftpFile> ListLastTenEnvisionSshFiles(ConnectionInfo connectionInfo,
string remoteSftpFilePath, int fileProcessorTopNumber)
=> DisposableService.Using(() => new SftpClient(connectionInfo), client =>
{
if (null == client)
{
return(null);
}
client.Connect();
var ftpDirectoryListing = client.ListDirectory(remoteSftpFilePath)?.ToList();
return(ftpDirectoryListing?.Where(f => !string.IsNullOrWhiteSpace(f.Name) &&
f.Name.ToLower().StartsWith(ComparisonString) &&
f.Name.Length == Count)
.OrderByDescending(f => f.Name).Take(fileProcessorTopNumber).ToList());
});
public void ServicesRegisteredByInstanceFromServiceCollectionShouldBeUntracked()
{
var svc = new DisposableService();
var services = new Registry();
services.AddSingleton(svc);
using (var container = services.CreateContainer()) {
var svc2 = container.GetService <DisposableService>();
Assert.Same(svc, svc2);
}
Assert.False(svc.Disposed);
}
private static IList <SftpFile> ListLastTenLakerSshFiles(ConnectionInfo connectionInfo,
string remoteSftpFilePath, int fileProcessorTopNumber)
{
return(DisposableService.Using(() => new SftpClient(connectionInfo), client =>
{
if (null == client)
{
return null;
}
client.Connect();
var ftpDirectoryListing = client.ListDirectory(remoteSftpFilePath)?.ToList();
return ftpDirectoryListing?.Where(f => !string.IsNullOrWhiteSpace(f.Name) &&
f.Name.ToLower().StartsWith("billing_claim_file_"))
.OrderByDescending(f => f.Name).Take(fileProcessorTopNumber).ToList();
}));
}
public void Dispose_RegistrationSingletonInstance_DoesNotDisposeThatInstance()
{
// Arrange
DisposableService instance = new DisposableService();
var container = ContainerFactory.New();
container.RegisterSingleton <IService>(instance);
container.GetInstance <IService>();
// Act
container.Dispose();
// Assert
Assert.IsFalse(instance.Disposed,
"When supplying an already created instance to the container, such instance considered to be " +
"'container uncontrolled' and the container should NOT dispose them, because the lifetime of " +
"such instance exceeds that of the container.");
}
public void DisposalPolicies()
{
var ioc = new ServiceContainer();
// Not disposable.
ioc.Register(typeof(IService1), null, new Service1());
// DisposalPolicy.Automatic
ioc.Register(typeof(IService1), null, typeof(DisposableService));
var service = ioc.GetInstance <IService1>();
// DisposalPolicy.Manual
var disposableService = new DisposableService();
ioc.Register(typeof(IService1), "Token", disposableService);
ioc.Dispose();
Assert.IsFalse(disposableService.Disposed);
Assert.IsTrue(((DisposableService)service).Disposed);
}
public void CleanUpDelegateTest()
{
var disposalScope = new DisposalScope();
var disposableService = new DisposableService();
var eventFired = false;
var cleanUpCalled = false;
disposableService.Disposing += (sender, args) => eventFired = true;
disposalScope.AddDisposable(disposableService,
disposed =>
{
Assert.True(ReferenceEquals(disposableService, disposed));
cleanUpCalled = true;
});
disposalScope.Dispose();
Assert.True(eventFired);
Assert.True(cleanUpCalled);
}
public static void ProcessLakerSftpOperation(SftpConnectionModel model, string remoteSftpFilePath,
string localSftpDownloadDirectoryFullPath, int fileProcessorTopNumber)
{
var connectionInfo = GetLakerConnectionInfo(model);
var lastTenLakerSftpFiles = ListLastTenLakerSshFiles(GetLakerConnectionInfo(model), remoteSftpFilePath,
fileProcessorTopNumber);
DisposableService.Using(() => new SftpClient(connectionInfo), client =>
{
client.Connect();
foreach (var sftpFile in lastTenLakerSftpFiles)
{
var fullLocalFileName = Path.Combine(localSftpDownloadDirectoryFullPath, sftpFile.Name);
if (File.Exists(fullLocalFileName))
{
continue;
}
DisposableService.Using <Stream>(() => File.Create(fullLocalFileName),
fileStream => { client.DownloadFile(remoteSftpFilePath + "/" + sftpFile.Name, fileStream); });
}
});
}
public async Task ExternalContainerInstanceCanBeUsedForEverything()
{
var disposables = new List <DisposableService>();
var containerFactory = new ExternalContainerFactory(services =>
{
services.AddSingleton(sp =>
{
var service = new DisposableService();
disposables.Add(service);
return(service);
});
});
var host = new WebHostBuilder()
.UseStartup <StartupWithExternalServices>()
.UseServer(new TestServer())
.ConfigureServices(services =>
{
services.AddSingleton <IServiceProviderFactory <IServiceCollection> >(containerFactory);
})
.Build();
using (host)
{
await host.StartAsync();
}
// We should create the hosting service provider and the application service provider
Assert.Equal(2, containerFactory.ServiceProviders.Count);
Assert.Equal(2, disposables.Count);
Assert.NotEqual(disposables[0], disposables[1]);
Assert.True(disposables[0].Disposed);
Assert.True(disposables[1].Disposed);
}
public void Dispose_RegistrationSingletonInstance_DoesNotDisposeThatInstance()
{
// Arrange
DisposableService instance = new DisposableService();
var container = ContainerFactory.New();
container.RegisterSingleton<IService>(instance);
container.GetInstance<IService>();
// Act
container.Dispose();
// Assert
Assert.IsFalse(instance.Disposed,
"When supplying an already created instance to the container, such instance considered to be " +
"'container uncontrolled' and the container should NOT dispose them, because the lifetime of " +
"such instance exceeds that of the container.");
}
public void InstanceShouldNotBeDisposed()
{
var ioc = new ServiceContainer();
// DisposalPolicy.Manual
var disposableService = new DisposableService();
ioc.Register(typeof(IService1), "Token", disposableService);
ioc.Dispose();
Assert.IsFalse(disposableService.Disposed);
}
public StartupWithExternalServices(DisposableService disposable)
{
DisposableServiceCtor = disposable;
}
public void Configure(IApplicationBuilder builder, DisposableService disposable)
{
DisposableService = disposable;
}
public void Configure(IApplicationBuilder app, DisposableService disposable)
{
DisposableServiceApp = disposable;
}
public StartupWithResolvedDisposableThatThrows(DisposableService service)
{
}
public TestCommand(DisposableService disposableService)
{
_disposableService = disposableService;
}
public void DisposalPolicies()
{
var ioc = new ServiceContainer();
// Not disposable.
ioc.Register(typeof(IService1), null, new Service1());
// DisposalPolicy.Automatic
ioc.Register(typeof(IService1), null, typeof(DisposableService));
var service = ioc.GetInstance<IService1>();
// DisposalPolicy.Manual
var disposableService = new DisposableService();
ioc.Register(typeof(IService1), "Token", disposableService);
ioc.Dispose();
Assert.IsFalse(disposableService.Disposed);
Assert.IsTrue(((DisposableService)service).Disposed);
}
