public void TestCreateScope <TService, TImplementation>(IDiContainer container)
where TService : class
{
using (var scope = container.CreateScope())
{
container = scope.Container;
var service = container.GetInstance <TService>();
Xunit.Assert.IsType <TImplementation>(service);
var service2 = container.GetInstance <TService>();
Xunit.Assert.IsType <TImplementation>(service2);
Xunit.Assert.Equal(service, service2);
using (var innerScope = container.CreateScope())
{
var scopedService = innerScope.Container.GetInstance <TService>();
Xunit.Assert.IsType <TImplementation>(scopedService);
var scopedService2 = innerScope.Container.GetInstance <TService>();
Xunit.Assert.IsType <TImplementation>(scopedService2);
Xunit.Assert.Equal(scopedService, scopedService2);
Xunit.Assert.NotEqual(service, scopedService);
}
}
}
public void RegisterNamedInterfaceWithClassAsSingleton()
{
const string info =
@"container
.RegisterInstance<IFoo, Foo>()
.RegisterInstance<IFoo, Foo>(""foo2"");
";
IDiContainer container = CreateConntainer();
container
.RegisterInstance <IFoo, Foo>()
.RegisterInstance <IFoo, Foo>("foo2");
const string additionalInfo1 = "container.GetInstance<IFoo>();";
IFoo instance1 = container.GetInstance <IFoo>();
instance1.Should().NotBeNull(info + additionalInfo1);
IFoo instance2 = container.GetInstance <IFoo>();
instance2.Should().BeSameAs(instance1, info + additionalInfo1);
const string additionalInfo2 = "container.GetInstance<IFoo>(\"foo2\")";
IFoo instance3 = container.GetInstance <IFoo>("foo2");
instance3.Should()
.NotBeNull(info + container.GetInstance <IFoo>("foo2"))
.And.NotBeSameAs(instance1, info + additionalInfo2);
IFoo instance4 = container.GetInstance <IFoo>("foo2");
instance4.Should().BeSameAs(instance3, info + additionalInfo2);
}
public void ResolveItemsFormChildContainer()
{
IDiContainer container = CreateConntainer();
container
.Register <IFoo, Foo>()
.Register <IBar, Bar>();
IDiContainer childContainer = container.CreateChildContainer();
childContainer.Register <IFoo, FooChild>();
IFoo instance = container.GetInstance <IFoo>();
instance.Should()
.NotBeNull()
.And.BeOfType <Foo>();
IFoo childInstance = childContainer.GetInstance <IFoo>();
childInstance.Should()
.NotBeNull()
.And.BeOfType <FooChild>();
IBar parentInstance = childContainer.GetInstance <IBar>();
parentInstance.Should()
.NotBeNull()
.And.BeOfType <Bar>();
(parentInstance as Bar).Foo.Should()
.NotBeNull()
.And.BeOfType <FooChild>();
}
public void RegisterNamedSpecificInstanceAsSingleton()
{
const string info =
@"container
.RegisterInstance<IFoo>(specificInstance1)
.RegisterInstance<IFoo>(""foo2"", specificInstance2);
";
Foo specificInstance1 = new Foo();
Foo specificInstance2 = new Foo();
IDiContainer container = CreateConntainer();
container
.RegisterInstance <IFoo>(specificInstance1)
.RegisterInstance <IFoo>("foo2", specificInstance2);
const string additionalInfo1 = "container.GetInstance<IFoo>();";
IFoo instance1 = container.GetInstance <IFoo>();
instance1.Should().BeSameAs(specificInstance1, info + additionalInfo1);
IFoo instance2 = container.GetInstance <IFoo>();
instance2.Should().BeSameAs(specificInstance1, info + additionalInfo1);
const string additionalInfo2 = "container.GetInstance<IFoo>(\"foo2\");";
IFoo instance3 = container.GetInstance <IFoo>("foo2");
instance3.Should().BeSameAs(specificInstance2, info + additionalInfo2);
IFoo instance4 = container.GetInstance <IFoo>("foo2");
instance4.Should().BeSameAs(specificInstance2, info + additionalInfo2);
}
public void RegisterNamedInterfaceWithClassAndReturnNewInstanceOnEachResolve()
{
const string info =
@"container
.Register<IFoo, Foo>()
.Register<IFoo, Foo>(""foo2"");
";
IDiContainer container = CreateConntainer();
container
.Register <IFoo, Foo>()
.Register <IFoo, Foo>("foo2");
const string additionalInfo1 = "container.GetInstance<IFoo>();";
IFoo instance1 = container.GetInstance <IFoo>();
instance1.Should()
.NotBeNull(info + additionalInfo1)
.And.BeOfType <Foo>(info + additionalInfo1);
const string additionalInfo2 = "container.GetInstance<IFoo>(\"foo2\");";
IFoo instance2 = container.GetInstance <IFoo>("foo2");
instance2.Should()
.BeOfType <Foo>(info + additionalInfo2)
.And.NotBeSameAs(instance1, info + additionalInfo2);
}
public void TestGetInstanceThrowsException <TService>(IDiContainer container)
where TService : class
{
Xunit.Assert.Throws <ResolveFailedException>(container.GetInstance <TService>);
Xunit.Assert.Throws <ResolveFailedException>(() => container.GetInstance(typeof(TService)));
Xunit.Assert.Throws <ResolveFailedException>(() => container.GetInstance <TService>("1"));
}
private void CheckScopedService <TService, TImplementation>(IDiContainer container)
where TService : class
where TImplementation : class
{
var service = container.GetInstance <TService>();
Assert.IsType <TImplementation>(service);
var service2 = container.GetInstance <TService>();
Assert.Equal(service, service2);
}
private static ITestService TestGetInstanceWithScopedServices(IDiContainer diContainer)
{
var scopedTestService = diContainer.GetInstance <ITestService>();
var scopedTestService2 = diContainer.GetInstance <ITestService>();
var scopedContainerFromContainer = diContainer.GetInstance <IDiContainer>();
var scopedTestServiceFromScopedDiContainer = scopedContainerFromContainer.GetInstance <ITestService>();
Assert.Same(scopedTestService, scopedTestServiceFromScopedDiContainer);
Assert.Same(scopedTestService, scopedTestService2);
return(scopedTestService);
}
public async Task Run()
{
_container = CreateDiContainer();
var apiBuilder = _container.GetInstance <IXmlRpcProxyBuilder <IHomeMaticXmlRpcApi> >();
var xmlRpcApiHmIp = apiBuilder
.ForUrl("http://homematic-ccu2:" + CcuRpcPorts.HomeMaticIp)
.Build();
var xmlRpcApi = apiBuilder
.ForUrl("http://homematic-ccu2:" + CcuRpcPorts.HomeMatic)
.Build();
var connection = new CcuConnection(xmlRpcApiHmIp);
var deviceInfos = await connection.GetDeviceInfosAsync();
var devices = await connection.GetDevicesAsync();
var temperature = await xmlRpcApi.GetValueAsync <double>("NEQ1142873:1", "TEMPERATURE");
Console.WriteLine($"Temperature: {temperature}");
var deviceDescriptions = await xmlRpcApiHmIp.ListDevicesAsync();
deviceDescriptions.ForEach(x => Console.WriteLine($"{x.Address}"));
Console.WriteLine();
await LoadParameterDescriptions(xmlRpcApiHmIp);
}
public void RegisterClassTypeAndReturnNewInstanceOnEachResolve()
{
const string info = "container.Register<Foo>();";
IDiContainer container = CreateConntainer();
container.Register <Foo>();
Foo instance1 = container.GetInstance <Foo>();
instance1.Should().NotBeNull(info);
Foo instance2 = container.GetInstance <Foo>();
instance2.Should().NotBeSameAs(instance1, info);
}
public object CreateViewForViewModel(object viewModel, object context)
{
var viewType = GetViewTypeForViewModel(viewModel, context);
var view = _diContainer.GetInstance(viewType) as DependencyObject;
return(view);
}
public void RegisterInterfaceWithClassAsSingleton()
{
const string info = "container.RegisterInstance<IFoo, Foo>();";
IDiContainer container = CreateConntainer();
container.RegisterInstance <IFoo, Foo>();
IFoo instance1 = container.GetInstance <IFoo>();
instance1.Should().NotBeNull(info);
IFoo instance2 = container.GetInstance <IFoo>();
instance2.Should().BeSameAs(instance1, info);
}
private IEfCoreEntityModelBuilder CreateEntityModelBuilder(Type entityModelBuilderType)
{
var entityModelBuilder = _diContainer?.GetInstance(entityModelBuilderType)
?? Activator.CreateInstance(entityModelBuilderType);
return((IEfCoreEntityModelBuilder)entityModelBuilder);
}
public void RegisterSpecificInstanceAsSingleton()
{
const string info = "container.RegisterInstance<IFoo>(specificInstance);";
Foo specificInstance = new Foo();
IDiContainer container = CreateConntainer();
container.RegisterInstance <IFoo>(specificInstance);
IFoo instance1 = container.GetInstance <IFoo>();
instance1.Should().BeSameAs(specificInstance, info);
IFoo instance2 = container.GetInstance <IFoo>();
instance2.Should().BeSameAs(specificInstance, info);
}
public void RegisterInterfaceWithClassUsingLambdaAsSingleton()
{
const string info = "container.RegisterInstance<IFoo>(c => new Foo());";
IDiContainer container = CreateConntainer();
container.RegisterInstance <IFoo>(c => new Foo());
IFoo instance1 = container.GetInstance <IFoo>();
instance1.Should()
.NotBeNull(info)
.And.BeOfType <Foo>(info);
IFoo instance2 = container.GetInstance <IFoo>();
instance2.Should().BeSameAs(instance1, info);
}
public ICommand Parse(string input)
{
var regex = new Regex(@"\s+");
var inputParts = regex.Split(input, 3);
if (string.IsNullOrEmpty(inputParts[0]))
{
return(new NullCommand(_serviceLocator.GetInstance <IPrinterHelper>()));
}
var commandName = GetCommandName(inputParts);
var commandFactory = GetCommandBy(commandName);
if (commandFactory != null)
{
return(commandFactory.CreateCommand(inputParts));
}
return(new NullCommand(_serviceLocator.GetInstance <IPrinterHelper>()));
}
public void RegisterInterfaceWithClassAndReturnNewInstanceOnEachResolve()
{
const string info = "container.Register<IFoo, Foo>();";
IDiContainer container = CreateConntainer();
container.Register <IFoo, Foo>();
IFoo instance1 = container.GetInstance <IFoo>();
instance1.Should()
.NotBeNull(info)
.And.BeOfType <Foo>(info);
IFoo instance2 = container.GetInstance <IFoo>();
instance2.Should()
.BeOfType <Foo>(info)
.And.NotBeSameAs(instance1, info);
}
public object GetInstance()
{
var reflectionInfo = reflector.GetReflectionInfo(type);
Requires.NotNull(reflectionInfo.ConstructorInfo, nameof(reflectionInfo.ConstructorInfo));
var args = reflectionInfo.ConstructorParametersTypes
.Select(t => diContainer.GetInstance(t))
.ToArray();
var instance = Activator.CreateInstance(type, args);
return(instance);
}
public void TestGetInstance <TService, TImplementation>(IDiContainer container)
where TService : class
where TImplementation : class
{
Xunit.Assert.Throws <ResolveFailedException>(container.GetInstance <IUnknownService>);
var helper = container.GetInstance <DiContainerTestHelper>();
Xunit.Assert.IsType <DiContainerTestHelper>(helper);
var service = container.GetInstance <TService>();
Xunit.Assert.IsType <TImplementation>(service);
var service2 = container.GetInstance(typeof(TService));
Xunit.Assert.IsType <TImplementation>(service2);
var service3 = container.GetService(typeof(TService));
Xunit.Assert.IsType <TImplementation>(service3);
}
public void ResolveConstructorDependencies()
{
IDiContainer container = CreateConntainer();
container
.Register <IFoo, Foo>()
.Register <IBar, Bar>();
IBar instance = container.GetInstance <IBar>();
instance.Should()
.NotBeNull()
.And.BeOfType <Bar>();
(instance as Bar).Foo.Should()
.NotBeNull()
.And.BeOfType <Foo>();
}
public TService GetInstance(IDiContainer container, string name)
{
return(container.GetInstance(_nameMap[name]) as TService);
}
private static IEnumerable <object> CreateParameters(IDiContainer container, MethodBase methodInfo)
{
return(methodInfo.GetParameters().Select(p => container.GetInstance(p.ParameterType)));
}
public object Create(Type classType)
{
return(_diContainer.GetInstance(classType));
}
public static T GetInstance <T>()
where T : class
{
return(DiContainer.GetInstance <T>());
}
