public void LazyResolve()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterSingleton <IOne, One>();
var a = resolver.Resolve <Three>();
var b = resolver.Resolve <Three>();
Assert.False(a.LazyOne.IsValueCreated);
Assert.False(b.LazyOne.IsValueCreated);
Assert.IsType <One>(a.LazyOne.Value);
Assert.True(a.LazyOne.IsValueCreated);
Assert.False(b.LazyOne.IsValueCreated);
Assert.IsType <One>(b.LazyOne.Value);
Assert.True(a.LazyOne.IsValueCreated);
Assert.True(b.LazyOne.IsValueCreated);
Assert.Same(a.LazyOne.Value, b.LazyOne.Value);
}
}
private static IResolver CreateResolver()
{
// Step 1 - Create a logger.
var log = NLogWrapper.GetLog("Default");
// Step 2 - Create a container.
var container = new TactContainer(log);
// Step 3 - Read and aggregate configuration files.
var config = container.BuildConfiguration(cb =>
cb.AddJsonFile("AppSettings.json"));
// Step 4 - Load assemblies from the configuration.
var assemblies = config.LoadAssembliesFromConfig();
// Step 5 - Create and validate configuration objects.
container.ConfigureByAttribute(config, assemblies);
// Step 6 - Register services by reflection using attributes.
container.RegisterByAttribute(assemblies);
// Step 7 - Initialize / start services in the container.
container.InitializeByAttribute(assemblies);
return(container);
}
public void RegisterTransient()
{
IOne a, b, c, d;
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterTransient <IOne, One>();
a = resolver.Resolve <IOne>();
b = resolver.Resolve <IOne>();
using (var child = resolver.BeginScope())
{
c = child.Resolve <IOne>();
d = child.Resolve <IOne>();
}
}
Assert.NotSame(a, b);
Assert.NotSame(a, c);
Assert.NotSame(a, d);
Assert.False(a.IsDisposed);
Assert.False(b.IsDisposed);
Assert.False(c.IsDisposed);
Assert.False(d.IsDisposed);
}
public void RegisterSingleton()
{
IOne a, b, c, d;
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterSingleton <IOne, One>();
a = resolver.Resolve <IOne>();
b = resolver.Resolve <IOne>();
using (var child = resolver.BeginScope())
{
c = child.Resolve <IOne>();
d = child.Resolve <IOne>();
}
Assert.Same(a, b);
Assert.Same(a, c);
Assert.Same(a, d);
Assert.False(a.IsDisposed);
}
Assert.True(a.IsDisposed);
}
public void PreventRecursion()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterTransient <Seven>();
Assert.Throws <InvalidOperationException>(() => resolver.Resolve <Seven>());
}
}
public void RegisterPerScope()
{
IOne a, b, c, d, e, f, g, h;
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterPerScope <IOne, One>();
a = resolver.Resolve <IOne>();
b = resolver.Resolve <IOne>();
Assert.Same(a, b);
Assert.False(a.IsDisposed);
using (var child1 = resolver.BeginScope())
{
c = child1.Resolve <IOne>();
d = child1.Resolve <IOne>();
Assert.NotSame(c, a);
Assert.Same(c, d);
Assert.False(c.IsDisposed);
using (var child2 = resolver.BeginScope())
{
e = child2.Resolve <IOne>();
f = child2.Resolve <IOne>();
Assert.NotSame(e, a);
Assert.NotSame(e, c);
Assert.Same(e, f);
Assert.False(e.IsDisposed);
}
using (var child3 = resolver.BeginScope())
{
g = child3.Resolve <IOne>();
h = child3.Resolve <IOne>();
Assert.NotSame(g, a);
Assert.NotSame(g, c);
Assert.NotSame(g, d);
Assert.Same(g, h);
Assert.False(g.IsDisposed);
}
Assert.False(a.IsDisposed);
Assert.False(c.IsDisposed);
Assert.True(e.IsDisposed);
Assert.True(g.IsDisposed);
}
}
Assert.True(a.IsDisposed);
Assert.True(c.IsDisposed);
}
public void EnumerableResolve()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterSingleton <ITwo, One>("Two");
var a = resolver.Resolve <Four>();
Assert.IsType <One>(a.Twos.Single());
}
}
public void RegisterByAttribute()
{
var log = new InMemoryLog();
using (var container = new TactContainer(log))
{
Assert.Throws <InvalidOperationException>(() => container.Resolve <ITester>());
container.RegisterByAttribute(typeof(Tester));
var tester = container.Resolve <ITester>();
Assert.IsType <Tester>(tester);
}
}
public void SingletonProxy()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterSingleton <IOne, One>();
resolver.RegisterProxy <ITwo, IOne>();
var two = resolver.Resolve <ITwo>();
var one = resolver.Resolve <IOne>();
Assert.Same(one, two);
}
}
public void GenericClassResolve()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
Assert.Throws <InvalidOperationException>(() => resolver.Resolve <Seven>());
var eightInt = resolver.Resolve <Eight <int> >();
Assert.Equal(typeof(int), eightInt.Type);
var eightBool = resolver.Resolve <Eight <bool> >();
Assert.Equal(typeof(bool), eightBool.Type);
}
}
public void FuncResolve()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterSingleton <ITwo, One>();
var a = resolver.Resolve <Five>();
var b = a.Func();
var c = a.Func();
Assert.IsType <One>(b);
Assert.Same(b, c);
}
}
public void GenericInterfaceResolve()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterTransient(typeof(IEight <>), typeof(Eight <>));
Assert.Throws <InvalidOperationException>(() => resolver.Resolve <Seven>());
var eightInt = resolver.Resolve <IEight <int> >();
Assert.Equal(typeof(int), eightInt.Type);
var eightBool = resolver.Resolve <IEight <bool> >();
Assert.Equal(typeof(bool), eightBool.Type);
}
}
public static void Container()
{
Thread.Sleep(2000);
System.Console.WriteLine("Start");
using (var container = new TactContainer(new EmptyLog()))
{
container.RegisterPerScope <IOne, One>();
container.RegisterPerScope <ITwo, Two>();
container.RegisterSingleton <IThree, Three>();
container.RegisterSingleton <IFour, Four>();
container.RegisterSingleton <IFive, Five>();
container.RegisterSingleton <ISix, Six>();
container.RegisterSingleton <ISeven, Seven>();
container.RegisterSingleton <IEigth, Eight>();
container.RegisterSingleton <INine, Nine>();
container.RegisterSingleton <ITen, Ten>();
var sw1 = Stopwatch.StartNew();
using (var scope = container.BeginScope())
{
scope.Resolve <IOne>();
scope.Resolve <ITen>();
}
sw1.Stop();
var sw2 = Stopwatch.StartNew();
for (var i = 0; i < 1000000; i++)
{
using (var scope = container.BeginScope())
{
scope.Resolve <IOne>();
scope.Resolve <ITen>();
}
}
sw2.Stop();
System.Console.WriteLine(sw1.ElapsedMilliseconds.ToString());
System.Console.WriteLine(sw2.ElapsedMilliseconds.ToString());
}
System.Console.WriteLine("Stop");
Thread.Sleep(2000);
}
public void DoNotIncludeUnkeyedInResolveAll()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterSingleton <IOne, One>();
var a = resolver.ResolveAll <IOne>().ToList();
Assert.Equal(0, a.Count);
resolver.RegisterSingleton <IOne, One>("Doh");
var b = resolver.ResolveAll <IOne>().ToList();
Assert.Equal(1, b.Count);
resolver.RegisterSingleton <IOne, One>("Ray");
var c = resolver.ResolveAll <IOne>().ToList();
Assert.Equal(2, c.Count);
}
}
public void ShouldRegisterFalse()
{
var logger = new InMemoryLog();
using (var container = new TactContainer(logger))
{
var map = new Dictionary <string, string>
{
{ "TestConfig.ShouldRegister", "false" }
};
var configBuilder = new ConfigurationBuilder();
configBuilder.AddInMemoryCollection(map);
var config = configBuilder.Build();
var types = new[] { typeof(TestConfig), typeof(Test) };
container.ConfigureByAttribute(config, types);
container.RegisterByAttribute(types);
Assert.Throws <InvalidOperationException>(() => container.Resolve <ITest>());
}
}
public void ShouldRegisterTrue()
{
var logger = new InMemoryLog();
using (var container = new TactContainer(logger))
{
var map = new Dictionary <string, string>
{
{ "TestConfig:ShouldRegister", "true" }
};
var configBuilder = new ConfigurationBuilder();
configBuilder.AddInMemoryCollection(map);
var config = configBuilder.Build();
var types = new[] { typeof(TestConfig), typeof(Test) };
container.ConfigureByAttribute(config, types);
container.RegisterByAttribute(types);
container.Resolve <ITest>();
}
}
public static int Main(string[] args)
{
// Determine what mode the application is running in.
if (!Enum.TryParse(args.FirstOrDefault() ?? "Both", out AppMode appMode))
{
var modes = string.Join(", ", Enum.GetNames(typeof(AppMode)));
Console.WriteLine($"First argument must specify a mode: {modes}");
return(-1);
}
// Step 1 - Create a logger.
var log = NLogWrapper.GetLog("Default");
// Step 2 - Create a container.
using (var container = new TactContainer(log))
{
// Step 3 - Read and aggregate configuration files.
var config = container.BuildConfiguration(cb => cb
.AddJsonFile("AppSettings.json")
.AddJsonFile($"AppSettings.{appMode}.json"));
// Step 4 - Load assemblies from the configuration.
var assemblies = config.LoadAssembliesFromConfig();
// Step 5 - Create and validate configuration objects.
container.ConfigureByAttribute(config, assemblies);
// Step 6 - Register services by reflection using attributes.
container.RegisterByAttribute(assemblies);
// Step 7 - Initialize / start services in the container.
container.InitializeByAttribute(assemblies);
// Wait for the user to press enter to exit the application.
TestApplication(container, appMode).Wait();
}
return(0);
}
public void PerScopeProxy()
{
using (var resolver = new TactContainer(new InMemoryLog()))
{
resolver.RegisterPerScope <IOne, One>();
resolver.RegisterProxy <ITwo, IOne>();
var twoA = resolver.Resolve <ITwo>();
var oneA = resolver.Resolve <IOne>();
Assert.Same(oneA, twoA);
using (var scope = resolver.BeginScope())
{
var twoB = scope.Resolve <ITwo>();
var oneB = scope.Resolve <IOne>();
Assert.Same(oneB, twoB);
Assert.NotSame(oneA, oneB);
}
}
}
public void ThrowOnFail()
{
using (var resolver = new TactContainer(new InMemoryLog()))
Assert.Throws <InvalidOperationException>(() => resolver.Resolve <IOne>());
}
