public static IUnityContainer AddMediator <T1, T2>(this IUnityContainer container)
{
var classes = AllClasses.FromAssemblies(typeof(T1).Assembly)
.Where(x => x.Name.Contains("Controller") == false &&
x.Name.Contains("Attribute") == false &&
x.Name.EndsWith("Message") == false &&
x.FullName.Contains("Data.Model") == false)
.ToList();
classes.AddRange(AllClasses.FromAssemblies(typeof(T2).Assembly)
.Where(x => x.Name.Contains("Controller") == false &&
x.FullName.Contains("Data.Model") == false)
.ToList());
return(container.RegisterClassesTypesAndInstances(classes));
}
private static void ConfigureUnity()
{
Ioc = new UnityContainer();
var assemblyList = new List <Assembly>()
{
Assembly.GetAssembly(typeof(safnet.iba.IdentityMap))
};
Ioc.RegisterTypes(
AllClasses.FromAssemblies(assemblyList),
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.ContainerControlled
);
}
private void AddMoulesFromLoadedAssemblies(IModuleCatalog moduleCatalog, List <Assembly> allAssemblies)
{
var modules = AllClasses.FromAssemblies(allAssemblies).Where(t => t.GetInterfaces().Contains(typeof(IModule)));
foreach (var module in modules)
{
modulesManager.AddModule(module.Assembly);
}
modules.Select(module => new ModuleInfo()
{
ModuleName = module.Name,
ModuleType = module.AssemblyQualifiedName,
Ref = "file://" + module.Assembly.Location
}).ToList().ForEach(moduleCatalog.AddModule);
}
public void Initialize()
{
this.container.RegisterTypes(
AllClasses.FromAssemblies(typeof(VRChatUtilModule).Assembly)
.Where(x => x.Namespace != null && x.Namespace.EndsWith(".Models")),
WithMappings.FromAllInterfacesInSameAssembly,
getLifetimeManager: WithLifetime.ContainerControlled);
this.container.RegisterTypes(
AllClasses.FromAssemblies(typeof(VRChatUtilModule).Assembly)
.Where(x => x.Namespace != null && x.Namespace.EndsWith(".Views")),
_ => new[] { typeof(object) },
WithName.TypeName);
this.regionManager.RequestNavigate("FrameRegion", "MainView");
}
public static void RegisterTypes(IUnityContainer container)
{
Log.Info("Configure Unity register types.");
// Explicit types registration: container.RegisterType(typeof (Startup));
container.RegisterType <IClcWorldContext, ClcWorldContext>(new HierarchicalLifetimeManager());
// Convention to resolve dependencies
container.RegisterTypes(
AllClasses.FromAssemblies(typeof(ICarService).Assembly),
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.Custom <HierarchicalLifetimeManager>
);
}
public void RegistersUsingTheHelperMethods()
{
var container = new UnityContainer();
container.RegisterTypes(AllClasses.FromAssemblies(typeof(MockLogger).GetTypeInfo().Assembly).Where(t => t == typeof(MockLogger)), WithMappings.FromAllInterfaces, WithName.Default, WithLifetime.ContainerControlled);
var registrations = container.Registrations.Where(r => r.MappedToType == typeof(MockLogger)).ToArray();
Assert.AreEqual(1, registrations.Length);
var mappingRegistration = registrations.Single(r => r.RegisteredType == typeof(ILogger));
Assert.AreSame(typeof(ILogger), mappingRegistration.RegisteredType);
Assert.AreSame(typeof(MockLogger), mappingRegistration.MappedToType);
Assert.AreEqual(null, mappingRegistration.Name);
Assert.IsInstanceOfType(mappingRegistration.LifetimeManager, typeof(ContainerControlledLifetimeManager));
}
public void WhenMappedToTypeHasNoInterfaceAndMappedToNoType()
{
IUnityContainer container = new UnityContainer();
container.RegisterTypes(
AllClasses.FromAssemblies(
Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name)),
Assembly.Load(new AssemblyName(RegistrationByConventionAssembly2Name))),
(t) => WithMappings.None(typeof(TypeWithNoInterface)),
WithName.TypeName,
null);
var resolved = container.Resolve <TypeWithNoInterface>("TypeWithNoInterface");
Assert.IsInstanceOfType(resolved, typeof(TypeWithNoInterface));
}
static void Main(string[] args)
{
var container = new UnityContainer();
container.RegisterTypes(
AllClasses.FromAssemblies(Assembly.GetExecutingAssembly()),
WithMappings.FromAllInterfaces,
WithName.Default,
WithLifetime.ContainerControlled
);
var sample = container.Resolve <ISample>();
Console.WriteLine(sample is Sample);
Console.ReadLine();
}
public void WhenRegisteringFromAssemblies()
{
var container = new UnityContainer();
container.RegisterTypes(
AllClasses.FromAssemblies(Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name))),
WithMappings.FromAllInterfaces,
WithName.TypeName,
null);
var reg = container.Resolve <IInterface3>("TypeImplementingI3");
Assert.IsInstanceOfType(reg, typeof(TypeImplementingI3));
AssertHelper.ThrowsException <ResolutionFailedException>(() => container.Resolve <ITypeImplementingI1>("TypeToRegisterInDifferentAssembly"));
}
public static void RegisterComponents(HttpConfiguration config)
{
var container = new UnityContainer();
var assemblies = BuildManager.GetReferencedAssemblies().Cast <Assembly>().ToArray();
container.RegisterTypes(
AllClasses.FromAssemblies(assemblies),
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.Transient);
container.RegisterType <OAuthAuthorizationServerProvider, AuthorizationServerProvider>();
config.DependencyResolver = new UnityDependencyResolver(container);
}
private static IMediator BuildMediator()
{
var container = new UnityContainer();
container.RegisterType <IMediator, Mediator>();
container.RegisterTypes(AllClasses.FromAssemblies(typeof(Ping).Assembly), WithMappings.FromAllInterfaces, GetName, GetLifetimeManager);
container.RegisterType(typeof(INotificationHandler <>), typeof(GenericHandler), GetName(typeof(GenericHandler)));
container.RegisterType(typeof(IAsyncNotificationHandler <>), typeof(GenericAsyncHandler), GetName(typeof(GenericAsyncHandler)));
container.RegisterInstance(Console.Out);
container.RegisterInstance <SingleInstanceFactory>(t => container.IsRegistered(t) ? container.Resolve(t) : null);
container.RegisterInstance <MultiInstanceFactory>(t => container.ResolveAll(t));
var mediator = container.Resolve <IMediator>();
return(mediator);
}
private static void ConfigureIocContainer()
{
string currentDir = AppDomain.CurrentDomain.BaseDirectory;
var assemblies = Directory.GetFiles(AppDomain.CurrentDomain.RelativeSearchPath ??
AppDomain.CurrentDomain.BaseDirectory, "FullApp.*.dll");
var allClasses = AllClasses.FromAssemblies(assemblies.Select(x => Assembly.LoadFile(x)));
foreach (var c in allClasses.Where(t => t.GetInterfaces().Any(i => i.GetCustomAttributes(typeof(AutoRegisterAttribute), true).Any())))
{
foreach (var t in c.GetInterfaces().Where(i => i.GetCustomAttributes(typeof(AutoRegisterAttribute), true).Any()))
{
unityContainer.RegisterType(t, c);
}
}
}
public static void RegisterComponents()
{
if (container == null)
{
container = new UnityContainer();
}
var assemblies = AssembliesToRegisterTypes();
container.RegisterTypes(
AllClasses.FromAssemblies(assemblies),
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.PerResolve);
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
/// <summary>Registers the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
public static void RegisterTypes(IUnityContainer container)
{
container.RegisterTypes(
AllClasses.FromAssemblies(typeof(UnityConfig).Assembly),
WithMappings.FromMatchingInterface,
WithName.Default
);
container.RegisterType<HttpContextBase>(new PerRequestLifetimeManager(), new InjectionFactory(c => new HttpContextWrapper(HttpContext.Current)));
container.RegisterType<ApplicationContext>(new InjectionFactory(c => ApplicationContext.Current));
container.RegisterType<UmbracoContext>(new PerRequestLifetimeManager(), new InjectionFactory(c => UmbracoContext.Current));
container.RegisterType<UmbracoHelper>(new PerRequestLifetimeManager(), new InjectionConstructor(typeof(UmbracoContext)));
container.RegisterType<ILogFactory, LogFactory>();
container.RegisterType<IFileSystem, FileSystem>();
container.RegisterType<Settings>(new ContainerControlledLifetimeManager());
}
private static IMediator BuildMediator()
{
var container = new UnityContainer();
container.RegisterTypes(AllClasses.FromAssemblies(typeof(IMediator).Assembly), WithMappings.FromAllInterfaces);
container.RegisterTypes(AllClasses.FromAssemblies(typeof(Ping).Assembly), WithMappings.FromAllInterfaces, GetName, GetLifetimeManager);
container.RegisterInstance(Console.Out);
var serviceLocator = new UnityServiceLocator(container);
var serviceLocatorProvider = new ServiceLocatorProvider(() => serviceLocator);
container.RegisterInstance(serviceLocatorProvider);
var mediator = container.Resolve <IMediator>();
return(mediator);
}
public static void Configure(IUnityContainer container)
{
// Get Entlib config source (Current is in Web.EnterpriseLibrary.config)
IConfigurationSource source = ConfigurationSourceFactory.Create();
// Config container from Policy injection config settings
var policyInjectionSettings = (PolicyInjectionSettings)source.GetSection(PolicyInjectionSettings.SectionName);
policyInjectionSettings.ConfigureContainer(container);
// Config retry policy
var retryPolicySettings = RetryPolicyConfigurationSettings.GetRetryPolicySettings(source);
// turn off throwIfSet for unit testing
RetryPolicyFactory.SetRetryManager(retryPolicySettings.BuildRetryManager(), throwIfSet: false);
// get factories from config
var policyFactory = new ExceptionPolicyFactory(source);
var dbFactory = new DatabaseProviderFactory(source);
var validationFactory = ConfigurationValidatorFactory.FromConfigurationSource(source);
// Set default locator
UnityServiceLocator locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
container
.AddNewExtension <Interception>()
// register Entlib types with appropiate factory
.RegisterType <ExceptionManager>(new InjectionFactory(c => policyFactory.CreateManager()))
.RegisterType <Database>(new InjectionFactory(c => dbFactory.CreateDefault()))
.RegisterInstance <ValidatorFactory>(validationFactory)
// use registration by convention extension for registering app types; IProfileStore, IUserRepository
.RegisterTypes(AllClasses.FromAssemblies(Assembly.GetExecutingAssembly()),
WithMappings.FromAllInterfacesInSameAssembly,
WithName.Default,
WithLifetime.ContainerControlled)
// register types with interception
.RegisterType <AExpense.Model.User>(new Interceptor <VirtualMethodInterceptor>(),
new InterceptionBehavior <TracingBehavior>())
.RegisterType <IExpenseRepository, ExpenseRepository>(new Interceptor <VirtualMethodInterceptor>(),
new InterceptionBehavior <PolicyInjectionBehavior>());
}
public static IUnityContainer GetContainer()
{
var container = new UnityContainer();
container.RegisterType <IMediator, Mediator>();
var classes = AllClasses.FromAssemblies(typeof(UnityConfiguration).Assembly)
.Where(x => x.Name.Contains("Controller") == false && x.FullName.Contains("Data.Models") == false)
.ToList();
container.RegisterTypes(classes, WithMappings.FromAllInterfaces, GetName, GetLifetimeManager);
container.RegisterInstance <SingleInstanceFactory>(t => container.IsRegistered(t) ? container.Resolve(t) : null);
container.RegisterInstance <MultiInstanceFactory>(t => container.ResolveAll(t));
container.RegisterInstance(AuthConfiguration.LazyConfig);
return(container);
}
public static void RegisterTypes(IUnityContainer unityContainer)
{
unityContainer.RegisterTypes(
AllClasses.FromAssemblies(Assembly.GetExecutingAssembly()), // pulls from a specific list in real code.
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.ContainerControlled);
unityContainer.RegisterType <ConfigurationStore, ConfigurationStore>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(typeof(ITypeMapFactory), AutoMapper.Mappers.MapperRegistry.Mappers))
.RegisterType <IConfigurationProvider, ConfigurationStore>()
.RegisterType <IConfiguration, ConfigurationStore>()
.RegisterType <IMappingEngine, MappingEngine>()
.RegisterType <ITypeMapFactory, TypeMapFactory>();
unityContainer.AddNewExtension <Interception>();
// register as interface interceptor.
//foreach (var registration in unityContainer.Registrations)
//{
// if (registration.RegisteredType.IsInterface)
// unityContainer.RegisterType(
// registration.RegisteredType,
// registration.MappedToType,
// registration.Name,
// new Interceptor<InterfaceInterceptor>(),
// new InterceptionBehavior<TestInterceptorBehavior>())
// ;
//}
// register as virtual method interceptor.
foreach (var registration in unityContainer.Registrations)
{
if (registration.RegisteredType.IsInterface)
{
unityContainer.RegisterType(
registration.RegisteredType,
registration.MappedToType,
registration.Name,
new Interceptor <VirtualMethodInterceptor>(),
new InterceptionBehavior <TestInterceptorBehavior>())
;
}
}
}
/// <summary>
/// When in doubt, just use as it is, without setting anything yourself
/// </summary>
/// <param name="assembliesToScan">The assemblies containing Interfaces/Implementations</param>
/// <param name="container">The Unity container</param>
public BaseContainer(string[] assembliesToScan = null, UnityContainer container = null)
{
HashSet <Assembly> assemblies;
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
if (assembliesToScan == null || assembliesToScan.Length == 0)
{
assemblies = new HashSet <Assembly>(loadedAssemblies);
}
else
{
HashSet <string> assemblyNamesSet = new HashSet <string>(assembliesToScan);
assemblies = new HashSet <Assembly>();
foreach (var assemblyName in assemblyNamesSet)
{
var assembly = loadedAssemblies.FirstOrDefault(x => x.GetName().Name == assemblyName);
try
{
if (assembly == null)
{
assembly = Assembly.Load(assemblyName);
}
assemblies.Add(assembly);
}
catch { }
}
// Try to include all the MultiTenancyFramework.* assemblies
foreach (var assembly in loadedAssemblies.Where(x => x.GetName().Name.StartsWith("MultiTenancyFramework")))
{
assemblies.Add(assembly);
}
}
Container = container ?? new UnityContainer();
// Convention-based mapping: IService/Service; and Open generics too
Container.RegisterTypes(
AllClasses.FromAssemblies(assemblies),
WithMappings.FromMatchingInterface,
WithName.Default);
// This won't work because Unity does not support IServiceProvider
//Container.RegisterInstance(typeof(IServiceProvider), Container);
}
/// <summary>Registers the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
private static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
// container.LoadConfiguration();
container.RegisterType <IDbContextStorage, HttpDbContextStorage>(new ContainerControlledLifetimeManager());
container.RegisterType(typeof(IDbContextProvider <>), typeof(SimpleDbContextProvider <>), new TransientLifetimeManager());
container.RegisterType <ITypeFinder, TypeFinder>(new ContainerControlledLifetimeManager());
//var repoAssemblies = AllClasses.FromAssemblies(Assembly.Load("Qxr.Tests.Repositories")).Where(t => typeof(IDependency).IsAssignableFrom(t));
//var serviceAssemblies = AllClasses.FromAssemblies(Assembly.Load("Qxr.Services")).Where(t => typeof(IDependency).IsAssignableFrom(t));
var repoAssemblies = AllClasses.FromAssemblies(Assembly.Load("Qxr.Tests.Repositories")).Where(t => t.Name.EndsWith("Repository"));
var serviceAssemblies = AllClasses.FromAssemblies(Assembly.Load("Qxr.Services")).Where(t => t.Name.EndsWith("Service"));
var allAssemblies = repoAssemblies.Concat(serviceAssemblies).ToList();
container.RegisterType <ILogger, Log4NetAdapter>(new ContainerControlledLifetimeManager());
var interceptionInjectionMembers = new InjectionMember[]
{
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <AuditLoggingBehavior>()
};
container.RegisterTypes(allAssemblies,
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.Transient, t => interceptionInjectionMembers);
container.RegisterType(typeof(IReadOnlyRepository <>), typeof(QxrTestRepositoryBase <>), interceptionInjectionMembers);
container.RegisterType(typeof(IRepository <>), typeof(QxrTestRepositoryBase <>), interceptionInjectionMembers);
container.RegisterType <IUnitOfWork, QxrTestUnitOfWork>(interceptionInjectionMembers);
//var loggerTypes = allAssemblies.Where(t => t.GetProperties().Any(c => c.PropertyType == typeof(ILogger)));
//container.RegisterTypes(loggerTypes,
// WithMappings.FromMatchingInterface,
// WithName.Default,
// WithLifetime.Transient, t => new InjectionMember[]
// {
// new InjectionProperty("Logger")
// });
container.RegisterType <IIocResolver, IocResolver>(new InjectionConstructor(container));
DbContextProviderFactory.Initialize(container.Resolve <IIocResolver>());
LoggingFactory.Initialize(container.Resolve <ILogger>());
new AutoMapperBootstrap(container.Resolve <ITypeFinder>()).CreateMappings();
}
private void AutoRegisterClasses(List <Assembly> allAssemblies)
{
var defaultRegisters = AllClasses.FromAssemblies(allAssemblies).Where(t => t.IsDefined(typeof(AutoRegisterAttribute), true));
foreach (var register in defaultRegisters)
{
if (register.IsAbstract)
{
continue;
}
foreach (var interface_ in register.GetInterfaces().Union(new[] { register }))
{
Container.GetContainer().RegisterType(interface_, register, null, new TransientLifetimeManager());
Console.WriteLine($"{interface_} as {register}");
}
}
}
public void WhenMultipleMappingsToSameInterfaceLastOneWinsWins()
{
IUnityContainer container = new UnityContainer();
container.RegisterTypes(
AllClasses.FromAssemblies(Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name))),
WithMappings.FromAllInterfacesInSameAssembly,
WithName.Default,
null,
null,
true);
var resolved1 = container.Resolve <ITypeImplementingI1>();
var resolved2 = container.Resolve <IInterface2>();
Assert.IsInstanceOfType(resolved1, typeof(TypeImplementingI12));
Assert.IsInstanceOfType(resolved2, typeof(TypeImplementingI12));
}
public static void RegisterComponents()
{
var container = new UnityContainer();
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
container.RegisterTypes(AllClasses.FromAssemblies(
BuildManager.GetReferencedAssemblies().Cast <Assembly>()
).Where(a => a.Namespace.StartsWith("MBOS.Data") || a.Namespace.StartsWith("MBOS.Service") || a.Namespace.StartsWith("MBOS.Mailing") || a.Namespace.StartsWith("MBOS.General"))
, WithMappings.FromMatchingInterface, WithName.Default
, WithLifetime.Hierarchical, overwriteExistingMappings: true
);
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
public void WhenMappingToInterfacesInSameAssemblyWithDefaultNames()
{
IUnityContainer container = new UnityContainer();
container.RegisterTypes(
AllClasses.FromAssemblies(Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name))),
WithMappings.FromAllInterfacesInSameAssembly,
WithName.Default,
null,
null,
true);
var resolved1 = container.Resolve <IInterface3>();
var resolved2 = container.Resolve <IInterface4>();
Assert.IsInstanceOfType(resolved1, typeof(TypeImplementingI3));
Assert.IsInstanceOfType(resolved2, typeof(TypeImplementingI4));
}
public void WhenFilteringToMatchingInterface()
{
IUnityContainer container = new UnityContainer();
var mappings = WithMappings.FromMatchingInterface(typeof(TypeImplementing8));
container.RegisterTypes(
AllClasses.FromAssemblies(Assembly.Load(new AssemblyName(RegistrationByConventionAssembly1Name))),
WithMappings.FromMatchingInterface,
WithName.TypeName,
WithLifetime.Transient,
null,
true);
var resolved = container.Resolve <ITypeImplementing8>("TypeImplementing8");
Assert.IsInstanceOfType(resolved, typeof(TypeImplementing8));
}
/// <summary>Registers the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
public static void RegisterTypes(IUnityContainer container)
{
// NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
// container.LoadConfiguration();
// TODO: Register your types here
// container.RegisterType<IProductRepository, ProductRepository>();
container.RegisterTypes(
AllClasses.FromAssemblies(typeof(UnityConfig).Assembly)
.Where(t => !(t.IsSubclassOf(typeof(Controller)))),
WithMappings.FromAllInterfacesInSameAssembly,
WithName.Default,
WithLifetime.ContainerControlled);
container.RegisterType <TraceSourceLogger>(
new InjectionConstructor("default"));
}
public override IEnumerable <Type> GetTypes()
{
return(AllClasses.FromAssemblies(_assemblies)
.Select(Type => new { Type, TypeInfo = Type.GetTypeInfo() })
.Where(t =>
{
return t.TypeInfo
.ImplementedInterfaces
.Where(type1 => type1.GenericTypeArguments.Any())
.Select(type1 => new { Type = type1, TypeDefinition = type1.GetGenericTypeDefinition() })
.Any(type1 => type1.TypeDefinition == typeof(IEntityConverter <,>) &&
t.TypeInfo.Assembly != typeof(IEntityConverter <,>).GetTypeInfo().Assembly&&
!t.TypeInfo.IsAbstract &&
t.TypeInfo.IsPublic &&
t.TypeInfo.DeclaredConstructors.Count() == 1);
})
.Select(t => t.Type));
}
/// <summary>Registers the type mappings with the Unity container.</summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to
/// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
public static void RegisterTypes(IUnityContainer container)
{
container.RegisterType <IIdentityRepositoryContext, IdentityRepositoryContext>();
container.RegisterTypes(
AllClasses.FromAssemblies(true, Assembly.Load("Ucoin.Authority.Repositories")),
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.Custom <PerRequestLifetimeManager>
);
container.RegisterTypes(
AllClasses.FromAssemblies(true, Assembly.Load("Ucoin.Authority.Services")),
WithMappings.FromMatchingInterface,
WithName.Default,
WithLifetime.Custom <PerRequestLifetimeManager>
);
}
public void Initialize()
{
// register models(singleton)
this.Container.RegisterTypes(
AllClasses.FromAssemblies(typeof(InputModule).Assembly)
.Where(x => x.Namespace.EndsWith(".Models")),
getFromTypes: WithMappings.FromAllInterfaces,
getLifetimeManager: WithLifetime.ContainerControlled);
// register views
this.Container.RegisterTypes(
AllClasses.FromAssemblies(typeof(InputModule).Assembly)
.Where(x => x.Namespace.EndsWith(".Views")),
getFromTypes: _ => new[] { typeof(object) });
// register views @ region
this.RegionManager.RegisterViewWithRegion(RegionNames.InputRegion, typeof(InputView));
}
public static void RegisterTypes(IUnityContainer container)
{
container.RegisterType <IUnitOfWork, UnitOfWork>(new PerRequestLifetimeManager());
container.RegisterType(typeof(IRepository <>), typeof(Repository <>));
container.RegisterType <IAuthenticationManager>(
new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));
container.RegisterType <IUserStore <ApplicationUser> >(
new InjectionFactory(x =>
{
return(new UserStore <ApplicationUser>(new UnitOfWork().Session));
}));
container.RegisterType <ApplicationSignInManager>();
container.RegisterType <ApplicationUserManager>();
container.RegisterTypes(AllClasses.FromAssemblies(Assembly.GetAssembly(typeof(IProductService))), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient);
}
