public override void Configure(Container container)
{
JsConfig.DateHandler = JsonDateHandler.ISO8601;
InitializeAutoMapper.InitializarAutomap();
SetConfig(new EndpointHostConfig
{
GlobalResponseHeaders =
{
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
},
});
SetConfig(new EndpointHostConfig
{
//EnableFeatures = Feature.All.Remove(Feature.All).Add(Feature.Xml | Feature.Json | Feature.Html).Add(Feature.Metadata),
});
//register any dependencies your services use, e.g:
IUnityContainer unityContainer = new UnityContainer();
//App Services
unityContainer.RegisterType <IClientesAppServices, ClientesAppServices>();
unityContainer.RegisterType <ICategoriasAppServices, CategoriasAppServices>();
var unityAdapter = new UnityContainerAdapter(unityContainer);
container.Adapter = unityAdapter;
}
/// <summary>
/// Creates an empty IoC container
/// </summary>
/// <returns></returns>
public static IContainer CreateIoCContainer()
{
var container = new UnityContainerAdapter();
ServiceLocator.IoC = container;
return container;
}
public void BuildConfiguration()
{
Guard.Against <ArgumentNullException>(Container == null, "Ошибка построения конфигурации: не определен Unity - контейнер");
Guard.Against <ArgumentNullException>(NCommonConfigActions != null && NCommonConfigGets != null, "Ошибка построения конфигурации: определено две взаимоисключающие конфигурации NCommon");
try
{
if (NCommonConfigActions != null)
{
var adapter = new UnityContainerAdapter(Container);
NCommonConfigActions(Configure.Using(adapter));
}
else if (NCommonConfigGets != null)
{
NCommonConfigGets(Container);
}
if (!BusinessOperationConfigs.IsNullOrEmpty())
{
BusinessOperationConfigs.ForEach(config => config.Value.Confugure(Container));
}
if (ProcessConfig != null)
{
ProcessConfig.Confugure(Container);
}
//Validate
var validStr = Container.GetMappingAsString();
}
catch (Exception e)
{
throw;
}
}
public override void Configure(Container container)
{
var unityContainer = new UnityContainer()
.AddNewExtension<BuildTracking>()
.AddNewExtension<LogCreation>();
var userRepository = new InMemoryAuthRepository();
this.Plugins.Add(new AuthFeature(() => new AuthUserSession(),
new IAuthProvider[] { new BasicAuthProvider()}));
this.Plugins.Add(new RegistrationFeature());
unityContainer.RegisterInstance<ICacheClient>(new MemoryCacheClient());
unityContainer.RegisterInstance<IUserAuthRepository>(userRepository);
unityContainer.RegisterInstance<IDbConnectionFactory>(new OrmLiteConnectionFactory("~/Database/SmartDom.db".MapServerPath(),
SqliteOrmLiteDialectProvider.Instance));
unityContainer.RegisterType<IOrmWrapper, OrmWrapper>();
unityContainer.RegisterType<IConfigurationRepository, AppConfigRepository>();
unityContainer.RegisterType<MediaAdapterAbstractFactory<SerialPort>, SerialPortAdapterFactory>(new ContainerControlledLifetimeManager());
unityContainer.RegisterType<ModbusMasterAbstractFactory<SerialPort>, RtuSerialModbusMasterFactory>(new ContainerControlledLifetimeManager());
unityContainer.RegisterType<IGenericRepository<Device>, DeviceDbRepository>(new ContainerControlledLifetimeManager(),
new InjectionMethod("Initialize"));
unityContainer.RegisterType<IDeviceAccessLayer, SerialAccessLayer>(new ContainerControlledLifetimeManager());
unityContainer.RegisterType<IMessageDecoder, MessageDecoder>();
unityContainer.RegisterType<IDeviceManager, DeviceManager>();
var unityAdapter = new UnityContainerAdapter(unityContainer);
container.Adapter = unityAdapter;
AddUser(userRepository);
}
public void TryResolveShouldReturnNullIfElementNotExist()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
object dependantA = containerAdapter.TryResolve(typeof(IDependantA));
Assert.IsNull(dependantA);
}
public void CanRegisterAndResolveUsingContainerAdapter()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType<IService, MockService>();
IService mockService = containerAdapter.Resolve(typeof(IService)) as IService;
Assert.IsInstanceOfType(mockService, typeof(IService));
}
public void CanRegisterAndResolveUsingContainerAdapter()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType <IService, MockService>();
IService mockService = containerAdapter.Resolve(typeof(IService)) as IService;
Assert.IsInstanceOfType(mockService, typeof(IService));
}
public void TryResolveShouldResolveTheElementIfElementExist()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType<IService, MockService>(new ContainerControlledLifetimeManager());
object dependantA = containerAdapter.TryResolve(typeof(IService));
Assert.IsNotNull(dependantA);
}
void RegisterTransientExplicitTypesWithDependencyCreator_ReturnsSameObjectsForTwoResolutions()
{
var container = new UnityContainerAdapter();
container.RegisterSingleton(typeof(ITestDependency), typeof(TestDependencyA), () => new TestDependencyA());
var firstResolution = container.Resolve <ITestDependency>();
var secondResolution = container.Resolve <ITestDependency>();
firstResolution.Should().BeSameAs(secondResolution);
}
void RegisterTransientDifferentContractAndImplementationWithDependencyCreator_ReturnsTwoDifferentObjectsForTwoResolutions()
{
var container = new UnityContainerAdapter();
container.RegisterTransient <ITestDependency, TestDependencyA>(() => new TestDependencyA());
var firstResolution = container.Resolve <ITestDependency>();
var secondResolution = container.Resolve <ITestDependency>();
firstResolution.Should().NotBeSameAs(secondResolution);
}
public void TryResolveShouldResolveTheElementIfElementExist()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType <IService, MockService>(new ContainerControlledLifetimeManager());
object dependantA = containerAdapter.TryResolve(typeof(IService));
Assert.IsNotNull(dependantA);
}
void RegisterSingletonSameType_ReturnsSameObjectsForTwoResolutions()
{
var container = new UnityContainerAdapter();
container.RegisterSingleton <TestDependencyA>();
var firstResolution = container.Resolve <TestDependencyA>();
var secondResolution = container.Resolve <TestDependencyA>();
firstResolution.Should().BeSameAs(secondResolution);
}
void RegisterSingletonWithDependencyCreator_ReturnsSameObjectsForTwoResolutions()
{
var container = new UnityContainerAdapter();
container.RegisterSingleton <ITestDependency>(() => new TestDependencyA());
var firstResolution = container.Resolve <ITestDependency>();
var secondResolution = container.Resolve <ITestDependency>();
firstResolution.Should().BeSameAs(secondResolution);
}
public static void Run(string[] args)
{
using (IContainer container = new UnityContainerAdapter())
{
container.RegisterType <IWindowsServiceController, WindowsServiceController>(LifetimeScope.Singleton);
using (var windowsServiceController = container.Resolve <IWindowsServiceController>())
{
windowsServiceController.RunModule(args);
}
}
}
public void CanRegisterAndResolveSingletonUsingContainerAdapter()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType<IService, MockService>(new ContainerControlledLifetimeManager());
IService mockService1 = containerAdapter.Resolve(typeof(IService)) as IService;
IService mockService2 = containerAdapter.Resolve(typeof(IService)) as IService;
Assert.IsNotNull(mockService1);
Assert.AreSame(mockService1, mockService2);
}
public void CanRegisterAndResolveSingletonUsingContainerAdapter()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType <IService, MockService>(new ContainerControlledLifetimeManager());
IService mockService1 = containerAdapter.Resolve(typeof(IService)) as IService;
IService mockService2 = containerAdapter.Resolve(typeof(IService)) as IService;
Assert.IsNotNull(mockService1);
Assert.AreSame(mockService1, mockService2);
}
public void ExportProviderResolvesServiceRegisteredByTypeTest()
{
// Setup
var unityContainer = new UnityContainer();
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
// Registration
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>();
var component = provider.GetExportedValue<IUnityOnlyComponent>();
Assert.That(component, Is.Not.Null);
Assert.That(component.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
}
public void MultipleImplementationAreRegisteredByTypeAsParameter_ResolvedCollectionContainsAllImplementations()
{
var adapter = new UnityContainerAdapter();
adapter.RegisterCollection(typeof(ITestDependency), new[] { typeof(TestDependencyA), typeof(TestDependencyB) });
var collection = adapter.Resolve <IEnumerable <ITestDependency> >().ToArray();
var firstItem = collection.First();
var secondItem = collection.Last();
firstItem.Should().BeOfType <TestDependencyA>();
secondItem.Should().BeOfType <TestDependencyB>();
}
public void ContainerBuilder_WithContainer_ContainerResolvesSameInstanceForRequestDispatcher()
{
// Arrange
var container = new UnityContainer();
var adapter = new UnityContainerAdapter(container);
// Act
var containerBuilder = new ContainerBuilder(name, adapter);
var dispatcher = container.Resolve <IRequestDispatcher>();
var dispatcher2 = container.Resolve <IDIRequestDispatcher>();
// Assert
Assert.That(dispatcher, Is.SameAs(dispatcher2));
}
public void ExportProviderResolvesServiceRegisteredByTypeAndRegistrationNameTest()
{
// Setup
var unityContainer = new UnityContainer();
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
// Registration
unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent2>("unityComponent2");
var component = provider.GetExportedValue <IUnityOnlyComponent>("unityComponent2");
Assert.That(component, Is.Not.Null);
Assert.That(component.GetType(), Is.EqualTo(typeof(UnityOnlyComponent2)));
}
public void IsRegistered_WithType_CallsUnityContainer()
{
// Arrange
var adapter = new UnityContainerAdapter(unityContainer);
// Act
adapter.IsRegistered <Service>();
// Assert
mockUnityContainer
.Verify(
m => m.IsRegistered(
It.IsIn(typeof(Service)),
It.IsAny <string>()),
Times.Once);
}
public void MultipleImplementationAreRegisteredByInstance_ResolvedCollectionContainsAllImplementations()
{
var adapter = new UnityContainerAdapter();
var instanceA = new TestDependencyA();
var instanceB = new TestDependencyB();
adapter.RegisterCollection(new ITestDependency[] { instanceA, instanceB });
var collection = adapter.Resolve <IEnumerable <ITestDependency> >().ToArray();
var firstItem = collection.First();
var secondItem = collection.Last();
firstItem.Should().BeSameAs(instanceA);
secondItem.Should().BeSameAs(instanceB);
}
public void Resolve_WithType_CallsUnityContainer()
{
// Arrange
var adapter = new UnityContainerAdapter(unityContainer);
// Act
var service = adapter.Resolve <Service>();
// Assert
mockUnityContainer
.Verify(
m => m.Resolve(
It.IsIn(typeof(Service)),
It.IsAny <string>(),
It.IsAny <ResolverOverride[]>()),
Times.Once);
}
public void ExportProviderResolvesServicesRegisteredByTypeTest()
{
// Setup
var unityContainer = new UnityContainer();
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
// Registration
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>();
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent2>("b");
var components = provider.GetExports<IUnityOnlyComponent>();
Assert.That(components, Is.Not.Null);
Assert.That(components.Count(), Is.EqualTo(2));
Assert.That(components.Select(t => t.Value).OfType<UnityOnlyComponent1>().Count(), Is.EqualTo(1));
Assert.That(components.Select(t => t.Value).OfType<UnityOnlyComponent2>().Count(), Is.EqualTo(1));
}
public void Register_WithType_WithSingleton_CallsUnityContainer()
{
// Arrange
var adapter = new UnityContainerAdapter(unityContainer);
// Act
adapter.Register <Service>(true);
// Assert
mockUnityContainer
.Verify(
m => m.RegisterType(
It.IsAny <Type>(),
It.IsAny <Type>(),
It.IsAny <string>(),
It.IsAny <ITypeLifetimeManager>()),
Times.Once);
}
public void CanResolveCascadingDependencies()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType<IDependantA, DependantA>();
container.RegisterType<IDependantB, DependantB>();
container.RegisterType<IService, MockService>(new ContainerControlledLifetimeManager());
IDependantA dependantA = containerAdapter.Resolve(typeof(IDependantA)) as IDependantA;
Assert.IsNotNull(dependantA);
Assert.IsInstanceOfType(dependantA, typeof(IDependantA));
Assert.IsNotNull(dependantA.MyDependantB);
Assert.IsInstanceOfType(dependantA.MyDependantB, typeof(IDependantB));
Assert.IsNotNull(dependantA.MyDependantB.MyService);
Assert.IsInstanceOfType(dependantA.MyDependantB.MyService, typeof(IService));
}
public void CanResolveCascadingDependencies()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
container.RegisterType <IDependantA, DependantA>();
container.RegisterType <IDependantB, DependantB>();
container.RegisterType <IService, MockService>(new ContainerControlledLifetimeManager());
IDependantA dependantA = containerAdapter.Resolve(typeof(IDependantA)) as IDependantA;
Assert.IsNotNull(dependantA);
Assert.IsInstanceOfType(dependantA, typeof(IDependantA));
Assert.IsNotNull(dependantA.MyDependantB);
Assert.IsInstanceOfType(dependantA.MyDependantB, typeof(IDependantB));
Assert.IsNotNull(dependantA.MyDependantB.MyService);
Assert.IsInstanceOfType(dependantA.MyDependantB.MyService, typeof(IService));
}
public void Register_WithInstance_CallsUnityContainer()
{
// Arrange
var adapter = new UnityContainerAdapter(unityContainer);
var service = new Service();
// Act
adapter.Register(service);
// Assert
mockUnityContainer
.Verify(
m => m.RegisterInstance(
It.IsIn(typeof(Service)),
It.IsAny <string>(),
It.IsAny <object>(),
It.IsAny <IInstanceLifetimeManager>()),
Times.Once);
}
public void ExportProviderResolvesServicesRegisteredByTypeTest()
{
// Setup
var unityContainer = new UnityContainer();
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
// Registration
unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent1>();
unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent2>("b");
var components = provider.GetExports <IUnityOnlyComponent>();
Assert.That(components, Is.Not.Null);
Assert.That(components.Count(), Is.EqualTo(2));
Assert.That(components.Select(t => t.Value).OfType <UnityOnlyComponent1>().Count(), Is.EqualTo(1));
Assert.That(components.Select(t => t.Value).OfType <UnityOnlyComponent2>().Count(), Is.EqualTo(1));
}
public void MefCannotResolveTypesRegisteredInUnityBeforeTrackingExtensionIsAddedTest()
{
// Setup
var unityContainer = new UnityContainer();
// Registration
unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent2>("unityComponent2");
// Further setup
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var container = new CompositionContainer(assemblyCatalog, provider);
Assert.That(delegate
{
container.GetExportedValue <IUnityOnlyComponent>("unityComponent2");
}, Throws.TypeOf <ImportCardinalityMismatchException>());
}
public void MefCanResolveLazyTypeRegisteredInUnityTest()
{
// Setup
var unityContainer = new UnityContainer();
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var container = new CompositionContainer(assemblyCatalog, provider);
UnityOnlyComponent1.InstanceCount = 0;
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent1>();
var lazyUnityComponent = container.GetExport<IUnityOnlyComponent>();
Assert.That(lazyUnityComponent, Is.Not.Null);
Assert.That(UnityOnlyComponent1.InstanceCount, Is.EqualTo(0));
Assert.That(lazyUnityComponent.Value, Is.Not.Null);
Assert.That(lazyUnityComponent.Value.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
Assert.That(UnityOnlyComponent1.InstanceCount, Is.EqualTo(1));
}
public void MefCanResolveLazyTypeRegisteredInUnityTest()
{
// Setup
var unityContainer = new UnityContainer();
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var container = new CompositionContainer(assemblyCatalog, provider);
UnityOnlyComponent1.InstanceCount = 0;
unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent1>();
var lazyUnityComponent = container.GetExport <IUnityOnlyComponent>();
Assert.That(lazyUnityComponent, Is.Not.Null);
Assert.That(UnityOnlyComponent1.InstanceCount, Is.EqualTo(0));
Assert.That(lazyUnityComponent.Value, Is.Not.Null);
Assert.That(lazyUnityComponent.Value.GetType(), Is.EqualTo(typeof(UnityOnlyComponent1)));
Assert.That(UnityOnlyComponent1.InstanceCount, Is.EqualTo(1));
}
public void MefCanResolveTypesRegisteredInUnityAfterTrackingExtensionIsAddedTest()
{
// Setup
var unityContainer = new UnityContainer();
// Enable tracking
TypeRegistrationTrackerExtension.RegisterIfMissing(unityContainer);
// Registration
unityContainer.RegisterType <IUnityOnlyComponent, UnityOnlyComponent2>("unityComponent2");
// Further setup
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var container = new CompositionContainer(assemblyCatalog, provider);
var component = container.GetExportedValue <IUnityOnlyComponent>("unityComponent2");
Assert.That(component, Is.Not.Null);
Assert.That(component.GetType(), Is.EqualTo(typeof(UnityOnlyComponent2)));
}
//, IEnumerable<Type> serviceExclusions = null)
public static void RegistrationByConvention(this UnityContainer container, BehaviorConfiguration configuration, Action<IConventionBuilder<LifetimeManager>, IImplementationFilter> convention)
{
if (configuration == null)
{
configuration = BehaviorConfiguration.Default;
}
var logger = new DiagnosticLogger(configuration);
var serviceMappingTracker = new ServiceMappingTracker(logger);
var implementationFilter = new ImplementationFilter();
var configServiceFilter = ((IBehaviorConfiguration)configuration).GetServiceFilter();
var adapter = new UnityContainerAdapter(container, serviceMappingTracker);
var asmSelector = new AssemblySelector();
var serviceExtractor = new ServiceExtractor();
var serviceFilterAggregator = new ServiceFilterAggregator(new IServiceFilter[] { configServiceFilter, implementationFilter, serviceExtractor, serviceMappingTracker });
using (var builder = new ConventionBuilder<LifetimeManager>(adapter, asmSelector, serviceFilterAggregator, serviceExtractor))
{
convention(builder, implementationFilter);
}
}
public void MefCannotResolveTypesRegisteredInUnityBeforeTrackingExtensionIsAddedTest()
{
// Setup
var unityContainer = new UnityContainer();
// Registration
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent2>("unityComponent2");
// Further setup
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var container = new CompositionContainer(assemblyCatalog, provider);
Assert.That(delegate
{
container.GetExportedValue<IUnityOnlyComponent>("unityComponent2");
}, Throws.TypeOf<ImportCardinalityMismatchException>());
}
public void MefCanResolveTypesRegisteredInUnityAfterTrackingExtensionIsAddedTest()
{
// Setup
var unityContainer = new UnityContainer();
// Enable tracking
TypeRegistrationTrackerExtension.RegisterIfMissing(unityContainer);
// Registration
unityContainer.RegisterType<IUnityOnlyComponent, UnityOnlyComponent2>("unityComponent2");
// Further setup
var adapter = new UnityContainerAdapter(unityContainer);
var provider = new ContainerExportProvider(adapter);
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var container = new CompositionContainer(assemblyCatalog, provider);
var component = container.GetExportedValue<IUnityOnlyComponent>("unityComponent2");
Assert.That(component, Is.Not.Null);
Assert.That(component.GetType(), Is.EqualTo(typeof(UnityOnlyComponent2)));
}
/// <summary>
/// Creates instance of BootstrapperRunner
/// </summary>
public BootstrapperRunner()
{
Container = new UnityContainerAdapter();
}
public void TryResolveShouldReturnNullIfElementNotExist()
{
IUnityContainer container = new UnityContainer();
IContainerFacade containerAdapter = new UnityContainerAdapter(container);
object dependantA = containerAdapter.TryResolve(typeof(IDependantA));
Assert.IsNull(dependantA);
}