/// <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)
		{

			#region Register repositories

			var rep_a = Assembly.GetAssembly(typeof(IRepository<>));
			container.RegisterTypes(AllClasses.FromAssemblies(rep_a),
				WithMappings.FromMatchingInterface,
				WithName.Default,
				x => new PerRequestLifetimeManager());

			#endregion

			#region Register services

			var serv_a = Assembly.GetAssembly(typeof(IService<>));
			container.RegisterTypes(AllClasses.FromAssemblies(serv_a),
				WithMappings.FromMatchingInterface,
				WithName.Default,
				x => new PerRequestLifetimeManager());

			#endregion

			container.RegisterType<RelaxSummerContext>(new PerRequestLifetimeManager());
		}
Example #2
0
        public static void InjectAll(IUnityContainer container)
        {
            container.RegisterTypes(RepositoriesRegistraton.GetTypes(),
                                    WithMappings.FromAllInterfaces,
                                    WithName.Default);

            container.RegisterTypes(Services.Impl.Services.GetTypes(),
                                    WithMappings.FromAllInterfaces,
                                    WithName.Default);

            container.RegisterType <IExportDataService, ExportDataServiceImpl>();


            container.RegisterType <IEmailService, EmailServiceImpl>();


            container.RegisterType <IPluginFactory, PluginFactoryImpl>();

            container.RegisterType <IEmailSendingService, EmailSendingServiceImpl>();

            //TODO Automatically load all assemblies that start with JoinRpg.Experimental.Plugin.*
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies()
                .Where(type => typeof(IPlugin).IsAssignableFrom(type)),
                WithMappings.FromAllInterfaces,
                WithName.TypeName);

            container.RegisterTypes(Registration.GetTypes(),
                                    WithMappings.FromAllInterfaces,
                                    WithName.Default);
        }
        /// <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();

            container.RegisterType<AccountController>(new InjectionConstructor());
            container.RegisterType<ManageController>(new InjectionConstructor());

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default
                );

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().
                    Where(
                        type =>
                            typeof (IRunAtInit).IsAssignableFrom(type) ||
                            typeof (IRunAtStartup).IsAssignableFrom(type) ||
                            typeof (IRunOnError).IsAssignableFrom(type) ||
                            typeof (IRunOnEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunAfterEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunBeforeEachRequest).IsAssignableFrom(type)),
                WithMappings.FromAllInterfaces,
                WithName.TypeName);
        }
Example #4
0
        /// <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>();
            //HttpContext object
            container.RegisterType <HttpContextBase>(new InjectionFactory(_ => new HttpContextWrapper(HttpContext.Current)));
            //Request object
            container.RegisterType <HttpRequestBase>(new InjectionFactory(_ => new HttpRequestWrapper(HttpContext.Current.Request)));
            //Response object for injection
            container.RegisterType <HttpResponseBase>(new InjectionFactory(_ => new HttpResponseWrapper(HttpContext.Current.Response)));

            container.RegisterType <IAuthenticationService, FormsAuthenticationService>();
            container.RegisterType <ISessionContext, SessionContext>();
            container.RegisterType <ILogService, LogService>();
            container.RegisterType <ISocialLoginService, SocialLoginService>();

            //per HTTP request. during the lifetime of a single HTTP request.
            container.RegisterType <IHeadTagBuilder, HeadTagBuilder>(new PerRequestLifetimeManager());

            var sdkClasses = AllClasses.FromLoadedAssemblies().Where(x => x.FullName.ToLower().StartsWith("omnicx.api.sdk"));

            container.RegisterTypes(sdkClasses, WithMappings.FromMatchingInterface, WithName.Default);

            container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(
                                        x => x.FullName.ToLower().StartsWith("omnicx.site")),
                                    WithMappings.FromMatchingInterface, WithName.Default);
        }
        /// <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();

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default
                );

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().
                    Where(
                        type =>
                            typeof (IRunAtInit).IsAssignableFrom(type) ||
                            typeof (IRunAtStartup).IsAssignableFrom(type) ||
                            typeof (IRunOnError).IsAssignableFrom(type) ||
                            typeof (IRunOnEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunAfterEachRequest).IsAssignableFrom(type) ||
                            typeof (IRunBeforeEachRequest).IsAssignableFrom(type)),
                WithMappings.FromAllInterfaces,
                WithName.TypeName);

            container.RegisterType<IAuthenticationManager>(new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));

            container.RegisterType<IUserStore<User>, UserStore<User>>(new InjectionConstructor(typeof (ApplicationDbContext)));

            container.RegisterType<IRoleStore<IdentityRole, string>, RoleStore<IdentityRole, string, IdentityUserRole>>(
                new InjectionConstructor(typeof (ApplicationDbContext)));
        }
        public static void RegisterTypes(IUnityContainer container)
        {
            // Dependencies are injected into HomeController

            // 1. Manual registrations
            //container.RegisterType<ICoreUserService, CoreUserService>(new PerResolveLifetimeManager());
            //container.RegisterType<ICoreLoginService, UkLoginService>(new PerResolveLifetimeManager());

            // 2. Very generic registration by convention
            //container.RegisterTypes(
            //	AllClasses.FromLoadedAssemblies(),
            //	WithMappings.FromMatchingInterface,
            //	WithName.Default,
            //	WithLifetime.ContainerControlled);

            // 3. Simplest possible extension of RegistrationConvention. It does exactly the same as the statement above
            //container.RegisterTypes(new BasicRegistrationByConvention());

            // 4. More complex example of RegistrationConvention extension.
            // The use case is a problem I face at work.
            // Core services are created and in some cases they are overridden by country services. E.g. CoreLoginService, UkLoginService.
            // Where country overrides exists in must be injected instead of the core service
            container.RegisterTypes(new CoreRegistrationByConvention());
            container.RegisterTypes(new UkRegistrationByConvention(), overwriteExistingMappings: true);
        }
Example #7
0
        public static void BuildUp(IUnityContainer container)
        {
            if (UnityContainer != null)
            {
                throw new InvalidOperationException("DomainUnityContainer already configured");
            }

            UnityContainer = container;

            UnityContainer.RegisterTypes(
                Assembly.GetExecutingAssembly().GetTypes().Where(t => t.IsSubclassOf(typeof(AbstractApplicationService))),
                WithMappings.FromMatchingInterface,
                getInjectionMembers: t => new InjectionMember[]
            {
                new Interceptor <InterfaceInterceptor>(),
                new InterceptionBehavior <PolicyInjectionBehavior>()
            });

            UnityContainer.RegisterTypes(
                Assembly.GetExecutingAssembly().GetTypes().Where(t => t.IsSubclassOf(typeof(AbstractDomainService))),
                WithMappings.FromMatchingInterface,
                getInjectionMembers: t => new InjectionMember[]
            {
                new Interceptor <InterfaceInterceptor>(),
                new InterceptionBehavior <PolicyInjectionBehavior>()
            });
        }
        /// <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();

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default
                );

            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().
                Where(
                    type =>
                    typeof(IRunAtInit).IsAssignableFrom(type) ||
                    typeof(IRunAtStartup).IsAssignableFrom(type) ||
                    typeof(IRunOnError).IsAssignableFrom(type) ||
                    typeof(IRunOnEachRequest).IsAssignableFrom(type) ||
                    typeof(IRunAfterEachRequest).IsAssignableFrom(type) ||
                    typeof(IRunBeforeEachRequest).IsAssignableFrom(type)),
                WithMappings.FromAllInterfaces,
                WithName.TypeName);

            container.RegisterType <IAuthenticationManager>(new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));

            container.RegisterType <IUserStore <User>, UserStore <User> >(new InjectionConstructor(typeof(ApplicationDbContext)));

            container.RegisterType <IRoleStore <IdentityRole, string>, RoleStore <IdentityRole, string, IdentityUserRole> >(
                new InjectionConstructor(typeof(ApplicationDbContext)));
        }
Example #9
0
 public void RegisterType(Assembly assembly)
 {
     _unityContainer.RegisterTypes(AllClasses.FromAssemblies(assembly),
                                   WithMappings.FromAllInterfaces,
                                   WithName.Default,
                                   WithLifetime.Transient);
 }
Example #10
0
        /// <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)
        {
            var serviceAssemblies    = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.StartsWith("TrainingWebAPI.Service")).ToArray();
            var repositoryAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.StartsWith("TrainingWebAPI.Repository")).ToArray();

            container.RegisterTypes(RegisterTypesScan.GetTypesWithCustomAttribute <BusinessLogicAttribute>(serviceAssemblies), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient,
                                    getInjectionMembers: t => new InjectionMember[] {
                new Interceptor <InterfaceInterceptor>(),    //Interception technique
                new InterceptionBehavior <BusinessLogicBehaviour>()
            });

            container.RegisterTypes(RegisterTypesScan.GetTypesWithCustomAttribute <DataAccessAttribute>(repositoryAssemblies),
                                    WithMappings.FromMatchingInterface,
                                    WithName.Default,
                                    WithLifetime.Transient,
                                    getInjectionMembers: t => new InjectionMember[] {
                new Interceptor <InterfaceInterceptor>(),    //Interception technique
                new InterceptionBehavior <DataAccessBehaviour>()
            });

            container
            .RegisterType <LogHandler>(new ContainerControlledLifetimeManager())
            .RegisterType <DbContext, EFTrainingEntities>(new ContainerControlledLifetimeManager());


            GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
        }
Example #11
0
        private static void RegisterTypes(IUnityContainer container)
        {
            RegisterBitlyService(container);
            container.RegisterType <ILuceneService, LuceneRamService>();
            container.RegisterType <IUnitOfWork, UnitOfWork>();
            container.RegisterType <IUserRepository, UserRepository>();
            container.RegisterInstance <IDbSession>(new DbSession());

            container.RegisterTypes(
                AllClasses.FromAssembliesInBasePath()
                .Where(t => t.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IEntityRepository <>))),
                WithMappings.FromMatchingInterface,
                WithName.Default);

            container.RegisterTypes(
                AllClasses.FromAssembliesInBasePath()
                .Where(t => Attribute.IsDefined(t, typeof(BusinessLogicAttribute))),
                WithMappings.FromMatchingInterface,
                WithName.Default);

            // Logging registered types.
            foreach (var item in container.Registrations)
            {
                Debug.WriteLine(item.RegisteredType + " - " + item.MappedToType + " - " + item.Name);
            }
        }
Example #12
0
        public void Configure(IUnityContainer container)
        {
            container.RegisterType <IResolveGenericTypes, UnityGenericTypeResolver>(new HierarchicalLifetimeManager());
            container.RegisterType <IManageReference, DefaultDatabaseReferenceManager>();

            container.RegisterType <ICreateFunctions, DefaultFunctionFactory>();

            var allClasses   = AllClasses.FromAssemblies(typeof(FrameworkInstaller).Assembly);
            var handlerTypes = allClasses.Where(t => typeof(IHandleReferences).IsAssignableFrom(t)).ToArray();

            container.RegisterTypes(handlerTypes, t => t.GetInterfaces()
                                    .Where(it => it.IsGenericType && typeof(IHandleReferences <>).IsAssignableFrom(it.GetGenericTypeDefinition())
                                           ));

            var commandProcessors = allClasses.Where(t => !t.IsInterface && !t.IsAbstract && t.GetInterfaces().Any(i => i.IsGenericType && typeof(IProcessCommands <>).IsAssignableFrom(i.GetGenericTypeDefinition())));

            container.RegisterTypes(commandProcessors, t => t.GetInterfaces().Where(i => i.IsGenericType && typeof(IProcessCommands <>).IsAssignableFrom(i.GetGenericTypeDefinition())));

            var operations = allClasses.Where(t => !t.IsInterface && !t.IsAbstract && t.GetInterfaces().Any(i => i.IsGenericType && typeof(IFunction <>).IsAssignableFrom(i.GetGenericTypeDefinition())));

            container.RegisterTypes(operations, t => t.GetInterfaces().Where(i => i.IsGenericType && typeof(IFunction <>).IsAssignableFrom(i.GetGenericTypeDefinition())));

            //var functionProviders = allClasses.Where(t => !t.IsInterface && !t.IsAbstract && t.GetInterfaces().Any(i => i.IsGenericType && typeof(IProvideFunctions<,,>).IsAssignableFrom(i.GetGenericTypeDefinition())));
            //container.RegisterTypes(functionProviders, t => t.GetInterfaces().Where(i => i.IsGenericType && typeof(IProvideFunctions<,,>).IsAssignableFrom(i.GetGenericTypeDefinition())));
        }
Example #13
0
        /// <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();
            //container.RegisterType<DbContext>();

            container.RegisterType <IAuthenticationManager>(
                new InjectionFactory(x => HttpContext.Current.GetOwinContext().Authentication));

            container.RegisterType <ApplicationDbContext>("ApplicationDbContext", new TransientLifetimeManager());

            container.RegisterType <IUnitOfWork, UnitOfWork>(
                new InjectionConstructor(container.Resolve <ApplicationDbContext>("ApplicationDbContext")));

            container.RegisterType <IObjectSetFactory, ObjectSetFactory>(
                new InjectionConstructor(container.Resolve <ApplicationDbContext>("ApplicationDbContext")));

            var repositories =
                Assembly.Load("MovieConnections.Framework")
                .GetTypes()
                .Where(x => !x.IsInterface && !x.IsAbstract && x.Name == "Repository`1")
                .ToList();

            container.RegisterTypes(
                repositories,
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.Transient
                );

            container.RegisterType <ApplicationUserStore>(
                new InjectionConstructor(container.Resolve <ApplicationDbContext>("ApplicationDbContext")));
            container.RegisterType <ApplicationRoleStore>(
                new InjectionConstructor(container.Resolve <ApplicationDbContext>("ApplicationDbContext")));

            container.RegisterType <IUserStore <ApplicationUser, int>, ApplicationUserStore>(
                new InjectionConstructor(container.Resolve <ApplicationDbContext>("ApplicationDbContext")));
            container.RegisterType <IRoleStore <ApplicationRole, int>, ApplicationRoleStore>(
                new InjectionConstructor(container.Resolve <ApplicationDbContext>("ApplicationDbContext")));

            var types = Assembly.Load("MovieConnections.Core").GetTypes()
                        .Where(x => !x.IsInterface && x.GetInterfaces().Contains(typeof(IDependency))).ToList();

            container.RegisterTypes(
                types,
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.Transient);

            //var culturedServices = Assembly.Load("MovieConnections.Core").GetTypes()
            //    .Where(x => !x.IsInterface && !x.IsAbstract && x.GetInterfaces().Contains(typeof(ICulturedDependency))).ToList();

            //foreach (var type in culturedServices) {
            //    container.RegisterType(typeof(CulturedBaseService<, ,>), type);

            //    container.RegisterType(typeof(ICulturedBaseService<,,>), type);
            //}
        }
Example #14
0
        /// <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.FromLoadedAssemblies().Where(t => t.Namespace == "PartyEC.BusinessServices.Services"), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient);
            container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "PartyEC.RepositoryServices.Services"), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient);
        }
Example #15
0
        /// <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 Unity.Configuration to the using statements.
            // container.LoadConfiguration();

            // TODO: Register your types here
            // container.RegisterType<IProductRepository, ProductRepository>();
            container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "PilotSmithApp.BusinessService.Service"), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient);
            container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "PilotSmithApp.RepositoryService.Service"), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient);
            //container.RegisterType<IDynamicUIBusiness, DynamicUIBusiness>();
            //SAMTOOL DEPENDENCIES
            container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "SAMTool.BusinessServices.Services"), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient);
            container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "SAMTool.RepositoryServices.Services"), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.Transient);
        }
Example #16
0
        public void Configure(IUnityContainer container)
        {
            var allTypes = AllClasses.FromAssemblies(typeof(ModuleInstaller).Assembly).ToArray();

            var handlerTypes = allTypes.Where(t => typeof(IHandleReferences).IsAssignableFrom(t)).ToArray();

            container.RegisterTypes(
                handlerTypes,
                t => t.GetInterfaces().Where(it => it.IsGenericType && typeof(IHandleReferences <>).IsAssignableFrom(it.GetGenericTypeDefinition())),
                t => t.GetInterfaces().Where(it => it.IsGenericType && typeof(IHandleReferences <>).IsAssignableFrom(it.GetGenericTypeDefinition())).FirstOrDefault().GetGenericArguments().FirstOrDefault().Name);

            var commandProcessors = allTypes.Where(t => !t.IsInterface && !t.IsAbstract && t.GetInterfaces().Any(i => i.IsGenericType && typeof(IProcessCommands <>).IsAssignableFrom(i.GetGenericTypeDefinition())));

            container.RegisterTypes(commandProcessors, t => t.GetInterfaces().Where(i => i.IsGenericType && typeof(IProcessCommands <>).IsAssignableFrom(i.GetGenericTypeDefinition())));
        }
        private static void RegisterServices(IUnityContainer container)
        {
            container.Configure <Interception>()
            .AddPolicy("ValidationPolicy")
            .AddMatchingRule <NamespaceMatchingRule>(
                new InjectionConstructor("Service.Impl", true)
                )
            .AddCallHandler(
                new ValidationCallHandler("", SpecificationSource.Both)
                )
            ;

            container.RegisterTypes(
                AllClasses.FromAssemblies(
                    new Assembly[] {
                Assembly.Load("Service.Impl"),
            }
                    ),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.ContainerControlled,
                getInjectionMembers: t => new InjectionMember[]
            {
                new Interceptor <InterfaceInterceptor>(),
                new InterceptionBehavior <ExceptionInterceptionBehavior>(),
                new InterceptionBehavior <SemanticLoggingInterceptionBehavior>(),
                new InterceptionBehavior <TransactionInterceptionBehavior <NureBotDbContext> >(),
                new InterceptionBehavior <PolicyInjectionBehavior>("ValidationPolicy")
            }
                );

            container.RegisterTypes(
                AllClasses.FromAssemblies(
                    new Assembly[] {
                Assembly.Load("TelegramNureBot.WPF")
            }
                    ),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.ContainerControlled,
                getInjectionMembers: t => new InjectionMember[]
            {
                new Interceptor <InterfaceInterceptor>(),
                new InterceptionBehavior <ExceptionInterceptionBehavior>(),
                new InterceptionBehavior <SemanticLoggingInterceptionBehavior>()
            }
                );
        }
Example #18
0
 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterTypes(AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default);
     container.RegisterType<IActivitiesMasterRepository, ActivitiesMasterRepository>();
     container.RegisterType<IDataRepositoryFactory, DataRepositoryFactory>();
     container.RegisterType<IBusinessEngineFactory, BusinessEngineFactory>();
 }
Example #19
0
 public static void RegisterServices(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace.StartsWith("Hangfire.Services.Impl") && !t.IsAbstract),
         FromMatchingInterface, WithName.Default, WithLifetime.ContainerControlled,
         getInjectionMembers: t => InterceptorSupport);
 }
        /// <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>();

            var myAssemblies =
                AppDomain.CurrentDomain.GetAssemblies()
                .Where(a => a.FullName.StartsWith(ClassesToScan))
                .ToArray();

            container.RegisterTypes(
                UnityConfig.GetTypesWithCustomAttribute <SingletonAttribute>(myAssemblies),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.ContainerControlled,
                null
                ).RegisterTypes(
                UnityConfig.GetTypesWithCustomAttribute <TransientLifetime>(myAssemblies),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.Transient);


            // used for SignalR
            //GlobalHost.DependencyResolver.Register(typeof(IHubActivator), () => new UnityHubActivator(GetConfiguredContainer()));
        }
Example #21
0
 private static void RegisterDao(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace.StartsWith("Hangfire.Dao.EntityFrameworkImpl.Dao") && !t.IsAbstract),
         UnityUtils.FromMatchingInterface, WithName.Default, WithLifetime.PerThread,
         getInjectionMembers: t => UnityUtils.InterceptorSupport);
 }
Example #22
0
        /// <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 Unity.Configuration to the using statements.
            // container.LoadConfiguration();

            // TODO: Register your type's mappings here.
            // container.RegisterType<IProductRepository, ProductRepository>();



            container.RegisterTypes
            (
                types: AllClasses.FromLoadedAssemblies().Where(x => x.Namespace.Contains("MoneyTemplateMVC")),
                getFromTypes: WithMappings.FromMatchingInterface,
                getName: WithName.Default,
                getLifetimeManager: WithLifetime.Custom <TransientLifetimeManager>,
                getInjectionMembers: null,
                overwriteExistingMappings: true
            );


            var connectionString = WebConfigurationManager.ConnectionStrings["SkillTreeHomeWork"].ToString();
            var providerName     = WebConfigurationManager.ConnectionStrings["SkillTreeHomeWork"].ProviderName;

            container.RegisterType <IConnectionFactory, ConnectionFactory>
            (
                new HierarchicalLifetimeManager(),
                new InjectionConstructor(connectionString, providerName)
            );
        }
        public static void RegisterTypesFromAssemblies(this IUnityContainer container, Assembly[] assemblies)
        {
            container.RegisterTypes(
                AllClasses.FromAssemblies(assemblies),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                (instanceType) => {
                LifetimeManager result = null;
                var ioc = instanceType.GetCustomAttributes(false).OfType <IOCAttribute>().FirstOrDefault();
                if (ioc == null)
                {
                    result = WithLifetime.Hierarchical(instanceType);
                }
                else
                {
                    switch (ioc.LifeCycle)
                    {
                    case IOCLifeCycleType.Singleton: result = WithLifetime.ContainerControlled(instanceType); break;

                    case IOCLifeCycleType.PerThread: result = WithLifetime.PerThread(instanceType); break;

                    case IOCLifeCycleType.PerResolve: result = WithLifetime.PerResolve(instanceType); break;

                    case IOCLifeCycleType.PerRequest: result = WithLifetime.Hierarchical(instanceType); break;

                    default: result = WithLifetime.Hierarchical(instanceType); break;
                    }
                }
                return(result);
            });
        }
        /// <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 Unity.Configuration to the using statements.
            // container.LoadConfiguration();

            //// TODO: Register your type's mappings here.
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.PerResolve);


            // 預設,每次都會 New
            // 後面註冊的會取代前面註冊的
            //container.RegisterType<IPaymentTransactionRepository, PaymentTransactionRepository>(new TransientLifetimeManager());
            container.RegisterType <IPaymentTransactionRepository, PaymentTransactionRepository>(new PerResolveLifetimeManager());
            container.RegisterType <IPayPalService, PayPalService>(new PerResolveLifetimeManager());
            container.RegisterType <IInvoiceService, InvoiceService>(new PerResolveLifetimeManager());
            //container.RegisterType<IRestClient, RestClient>(new PerResolveLifetimeManager());
            container.RegisterType <IRestClient, RestClient>(new PerResolveLifetimeManager(), new InjectionConstructor());
            // 同一個生命週期不會重新 new
            //container.RegisterType<IPaymentTransactionRepository, PaymentTransactionRepository>(new PerResolveLifetimeManager());

            //// Singleton
            //container.RegisterType<IPaymentTransactionRepository, PaymentTransactionRepository>(new ContainerControlledLifetimeManager());
        }
Example #25
0
        void ConfigureContainer()
        {
            _unityContainer = new UnityContainer();

            //register items by convention scanning
            //specific assemblies
            var assembliesToScan = new Assembly[]
            {
                /*MyCompany.Expenses.Data*/
                typeof(IEmployeeRepository).Assembly,
                /*MyCompany.Expenses.WebApiRole*/
                typeof(ISecurityHelper).Assembly,
            };

            _unityContainer.RegisterTypes(
                AllClasses.FromAssemblies(assembliesToScan),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.Transient);

            // Event Bus
            _unityContainer.RegisterType <IEventBus, AzureExpensesEventBus>();

            //bool eventBusEnabled = false;
            //Boolean.TryParse(RoleEnvironment.GetConfigurationSettingValue("EventBusEnabled"), out eventBusEnabled);
            //_unityContainer.RegisterType<IExpenseRepository, ExpenseRepository>(new InjectionConstructor(typeof(IEventBus), eventBusEnabled, typeof(MyCompanyContext)));
        }
Example #26
0
        /// <summary>
        /// Initializes the feed (unity)
        /// </summary>
        protected virtual void InitFeed()
        {
            if (FeedInitialized)
            {
                return;
            }

            lock (_lockInitialized)
            {
                if (FeedInitialized)
                {
                    return;
                }

                InternalConfig.Load(); // loads bookmaker_details
                if (InternalConfig.BookmakerDetails == null)
                {
                    _log.LogError("Token not accepted.");
                    return;
                }

                UnityContainer.RegisterTypes(this, InternalConfig);
                UnityContainer.RegisterAdditionalTypes();

                UpdateDependency();

                _feedRecoveryManager = UnityContainer.Resolve <IFeedRecoveryManager>();
                _connectionValidator = UnityContainer.Resolve <ConnectionValidator>();

                FeedInitialized = true;
            }
        }
Example #27
0
 private static void RegisterControllers(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies()
         .Where(t => t.Namespace.StartsWith("Hangfire.Web.Api.Controllers")),
         WithMappings.None, WithName.Default, WithLifetime.Hierarchical, getInjectionMembers: t => UnityUtils.InterceptorSupport);
 }
Example #28
0
 /// <summary>
 /// Registers classes with SpecFlow BindingAttribute into the container with default naming and container controller lifetime.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="container"></param>
 public static void RegisterStepDefinitions <T>(this IUnityContainer container)
 {
     container.RegisterTypes(typeof(T).Assembly.GetTypes().Where(t => Attribute.IsDefined(t, typeof(BindingAttribute))),
                             WithMappings.FromMatchingInterface,
                             WithName.Default,
                             WithLifetime.ContainerControlled);
 }
Example #29
0
        /// <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 <IUnitOfWork, MyDbContext>(new PerRequestLifetimeManager());
            container.RegisterType <DbContext, MyDbContext>(new PerRequestLifetimeManager());

            container.RegisterType <ApplicationUserManager>(new PerRequestLifetimeManager());
            container.RegisterType <IAuthenticationManager>(
                new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));
            container.RegisterType <ApplicationSignInManager>(new PerRequestLifetimeManager());

            container.RegisterType <IIdentityMessageService, EmailService>();

            RepositoriesRegistraton.Register(container);

            Services.Impl.Services.Register(container);

            container.RegisterType <IExportDataService, ExportDataServiceImpl>();

            container.RegisterType <IUriService>(new InjectionFactory(c => new UriServiceImpl(new HttpContextWrapper(HttpContext.Current))));

            container.RegisterType <IEmailService, EmailServiceImpl>();

            container.RegisterType <IMailGunConfig, ApiSecretsStorage>();

            container.RegisterType <IUserStore <User, int>, MyUserStore>();

            container.RegisterType <IPluginFactory, PluginFactoryImpl>();

            //TODO Automatically load all assemblies that start with JoinRpg.Experimental.Plugin.*
            container.RegisterTypes(AllClasses.FromLoadedAssemblies().Where(type => typeof(IPlugin).IsAssignableFrom(type)),
                                    WithMappings.FromAllInterfaces, WithName.TypeName);
        }
Example #30
0
 private static void RegisterByConvention(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace.StartsWith("LycanTally")),
         WithMappings.FromMatchingInterface,
         WithName.Default);
 }
Example #31
0
 public static void RegisterDao(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace.StartsWith("Hangfire.Dao.EntityFrameworkImpl.Dao") && !t.IsAbstract),
         FromMatchingInterface, WithName.Default, WithLifetime.ContainerControlled,
         getInjectionMembers: t => InterceptorSupport);
 }
Example #32
0
 private static void RegisterControllers(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies()
             .Where(t => t.Namespace.StartsWith("Hangfire.Web.Api.Controllers")),
         WithMappings.None, WithName.Default, WithLifetime.Hierarchical, getInjectionMembers: t => UnityUtils.InterceptorSupport);
 }
Example #33
0
        /// <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 Unity.Configuration to the using statements.
            // container.LoadConfiguration();

            // TODO: Register your type's mappings here.
            // container.RegisterType<IProductRepository, ProductRepository>();

            //container.RegisterType<IProteinTrackerService, ProteinTrackerService>();
            //container.RegisterType<IProteinRepository, ProteinRepository>();
            //container.RegisterType(AllClasses)
            var assemblylist = new List <Assembly>
            {
                typeof(Controllers.ProteinTrackerController).Assembly
            };

            container.RegisterTypes(
                AllClasses.FromAssemblies(assemblylist),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.Transient);

            //container.RegisterType<IProteinRepository, ProteinRepository>(new InjectionConstructor("Default Datasource"));

            container.RegisterInstance(typeof(IProteinRepository), new ProteinRepository("Instance Datasource"));

            container.RegisterType <IProteinRepository, ProteinRepository>("StandardRepository",
                                                                           new InjectionConstructor("Default Datasource"));
            container.RegisterType <IProteinRepository, DebugProteinRepository>("DebugRepository");

            container.RegisterType <IProteinTrackerService, ProteinTrackerService>(
                new InjectionConstructor(container.Resolve <IProteinRepository>("DebugRepository")));
        }
Example #34
0
 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterTypes(
         AllClasses.FromLoadedAssemblies(),
         WithMappings.FromMatchingInterface,
         WithName.Default);
 }
    public static void RegisterTypes(IUnityContainer container)
    {
        container.RegisterTypes(
           AllClasses.FromLoadedAssemblies(),
           WithMappings.FromMatchingInterface,
           WithName.Default);

        //Injection Constructor
        //container.RegisterType<IProteinRepository, ProteinRepository>(new InjectionConstructor("test data"));
        
        //Using register Instance
        //container.RegisterInstance(typeof(IProteinRepository), new ProteinRepository("test data 123"));

        //Named Registration
        container.RegisterType<IProteinRepository, ProteinRepository>("StandardRepository", new InjectionConstructor("test"));
        container.RegisterType<IProteinRepository, DebugProteinRepository>("DebugProteinRepository");

        //Named Registration
        var repositoryType = WebConfigurationManager.AppSettings["RepositoryType"];
        container.RegisterType<IProteinTrackingService, ProteinTrackingService>(
            new InjectionConstructor(container.Resolve<IProteinRepository>(repositoryType)));

        //container.RegisterType<IProteinTrackingService, ProteinTrackingService>();
        //container.RegisterType<IProteinRepository, ProteinRepository>();
    }
    protected override void ConfigureContainer(IUnityContainer container)
    {
        //Attach hook for AOP attributes
        container.AddNewExtension <Interception>();

        // register all your components with the container here
        // container
        //    .RegisterType<IService1, Service1>()
        //    .RegisterType<DataContext>(new HierarchicalLifetimeManager());

        container.RegisterTypes(AllClasses.FromLoadedAssemblies(),
                                WithMappings.FromMatchingInterface,
                                WithName.Default,
                                null,    //WithLifetime IF we want to change the lifetime aspect aka Singletons
                                GetMembers,
                                false
                                );

        container.RegisterType <IPaymentService, PaymentService>();
        container.RegisterType <IPaymentManager, PaymentManager>();
        container.RegisterType <IPaymentMethodRepository, PaymentMethodRepository>();
        container.RegisterType <IPaymentWithdrawScheduleRepository, PaymentWithdrawScheduleRepository>();
        container.RegisterType <IPaymentPreEnrollmentRepository, PaymentPreEnrollmentRepository>();
        container.RegisterType <ISharedLoanDataRepository <tblPaymentMethod>, SharedLoanDataRepository <tblPaymentMethod> >();
        container.RegisterType <ISharedLoanDataRepository <tblPaymentWithdrawSchedule>, SharedLoanDataRepository <tblPaymentWithdrawSchedule> >();
        container.RegisterType <IPaymentWithdrawScheduleOffSetTypeRepository, PaymentWithdrawScheduleOffSetTypeRepository>();
        container.RegisterType <IPaymentMethodTypeRepository, PaymentMethodTypeRepository>();
        container.RegisterType <IPaymentWithdrawScheduleFrequencyTypeRepository, PaymentWithdrawScheduleFrequencyTypeRepository>();
        container.RegisterType <IPaymentCustomerNotificationRepository, PaymentCustomerNotificationRepository>();
        container.RegisterType <ITraceLogger, TraceLogger>();
        container.RegisterType <IPaymentWithdrawScheduleCancelReasonRepository, PaymentWithdrawScheduleCancelReasonRepository>();
    }
Example #37
0
        public static void RegisterTypes(IUnityContainer container)
        {
            // Register your types here
            var assemblies = new Assembly[]
            {
                typeof(IConfigGateway).Assembly,
                typeof(IAnnouncementRepository).Assembly,
                typeof(IAnnouncementService).Assembly,
                typeof(ISessionRepository).Assembly,
                typeof(ISessionService).Assembly
            };

            Func <Type, LifetimeManager> getLifetimeManager = type =>
            {
                return(new PerRequestLifetimeManager());
            };

            container.RegisterTypes(AllClasses.FromAssemblies(assemblies),
                                    WithMappings.FromMatchingInterface,
                                    WithName.Default,
                                    getLifetimeManager);

            container.RegisterType <IDatabase, Database>(
                getLifetimeManager(typeof(Database)),
                new InjectionConstructor("LCMSDB"));

            TraceRegistrations(container);
        }
Example #38
0
        /// <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>();


            //My Custom codes
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default);
            //container.RegisterType<IProteinRepository, ProteinRepository>(new InjectionConstructor("test.data.source"));
            //container.RegisterInstance(typeof(IProteinRepository), new ProteinRepository("data.source"));

            container.RegisterType <IProteinRepository, ProteinRepository>("StandardRepository", new InjectionConstructor("std.data.source"));
            container.RegisterType <IProteinRepository, DebugProteinRepository>("DebugRepository", new InjectionConstructor("debug.data.source"));

            var repositoryType = WebConfigurationManager.AppSettings["RepositoryType"];

            container.RegisterType <IProteinTrackingService, ProteinTrackingService>(
                new InjectionConstructor(container.Resolve <IProteinRepository>(repositoryType)));

            //container.RegisterType<IProteinTrackingService, ProteinTrackingService>();
            //container.RegisterType<IProteinRepository, ProteinRepository>();
        }
Example #39
0
        void ConfigureContainer()
        {
            _unityContainer = new UnityContainer();

            //register items by convention scanning
            //specific assemblies
            var assembliesToScan = new Assembly[]
            {
                /*MyCompany.Vacation.Data*/
                typeof(IEmployeeRepository).Assembly,
                /*MyCompany.Vacation.Web*/
                typeof(ISecurityHelper).Assembly,
                /*MyCompany.Common.Notification*/
                typeof(INotificationService).Assembly,
            };

            _unityContainer.RegisterTypes(
                AllClasses.FromAssemblies(assembliesToScan),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.Transient);


            // Event Bus
            _unityContainer.RegisterType <IEventBus, AzureVacationEventBus>();

            bool eventBusEnabled = false;

            Boolean.TryParse(WebConfigurationManager.AppSettings["EventBusEnabled"], out eventBusEnabled);
            _unityContainer.RegisterType <IVacationRequestRepository, VacationRequestRepository>(new InjectionConstructor(typeof(MyCompanyContext), typeof(IEventBus), typeof(IWorkingDaysCalculator), eventBusEnabled));

            // Notification service
            _unityContainer.RegisterType <IEmailTemplatesRepository, EmailTemplatesInFileRepository>();
            _unityContainer.RegisterType <INotificationService, BaseNotificationService>();
        }
Example #40
0
 private void InitializeContainer()
 {
     _container = new UnityContainer();
     _container.RegisterTypes(
         AllClasses.FromAssembliesInBasePath(),
         WithMappings.FromMatchingInterface,
         WithName.Default);
 }
Example #41
0
        public static void RegisterTypes(IUnityContainer container)
        {
            container.RegisterTypes(AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default);
            container.RegisterType<IBlogRepository, BlogRepository>();
            container.RegisterType<IOAuthTwitterWrapper, OAuthTwitterWrapper>();

            //container.RegisterType<UserStore<CustomUser>>(new HierarchicalLifetimeManager());
            container.RegisterType<DbContext, IdentityContext>(new HierarchicalLifetimeManager());
        }
Example #42
0
        /// <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.RegisterTypes(AllClasses.FromLoadedAssemblies(),
                                     WithMappings.FromMatchingInterface,
                                     WithName.Default);
        }
Example #43
0
        /// <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)
        {
            var types = AllClasses.FromLoadedAssemblies().Where(x => x.Namespace.StartsWith("Rps."));

            container.RegisterTypes(
                types,
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.Transient);
        }
Example #44
0
        public static void RegisterTypes(IUnityContainer container)
        {
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default
                );

            container.RegisterType<AccountController>(new InjectionConstructor());
        }
Example #45
0
        public static void RegisterTypes(IUnityContainer container)
        {
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default);

            //container.RegisterType<IProteinTrackingService, ProteinTrackingService>();
            //container.RegisterType<IProteinRepository, ProteinRepository>();
        }
        public static void RegisterComponents(IUnityContainer container)
        {
            container.RegisterTypes(
                AllClasses.FromAssemblies(Assembly.GetAssembly(typeof(UnityConfig)),
                    Assembly.GetAssembly(typeof(Historian))),
                WithMappings.FromMatchingInterface, WithName.Default);

            container.RegisterType<IWorkItemRepository, WorkItemRepository>(new InjectionFactory(c => new WorkItemRepositoryFactory().CreateRepository()));
            DependencyResolver.SetResolver(new UnityDependencyResolver(container));
        }
Example #47
0
 private static void RegisterServices(IUnityContainer unityContainer)
 {
     unityContainer.RegisterTypes(
         AllClasses.FromLoadedAssemblies().Where(t => t.Namespace == "Hangfire.Services.Impl"),
         WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.ContainerControlled,
         getInjectionMembers: t => new InjectionMember[]
         {
             new Interceptor<VirtualMethodInterceptor>(),
             new InterceptionBehavior<PolicyInjectionBehavior>(),
         });
 }
Example #48
0
 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterTypes(AllClasses.FromLoadedAssemblies(),
             WithMappings.FromMatchingInterface,
             WithName.Default);
     container.RegisterType<IServiceFactory, ServiceFactory>();
     container.RegisterType<IActivitiesService, ActivityClient>();
     container.RegisterType<ILocationService, LocationClient>();
     container.RegisterType<IUsersService, UserClient>();
     container.RegisterType<ILoginService, LoginService>();
 }
Example #49
0
        public static void RegisterTypes(IUnityContainer container) {
            container.LoadConfiguration();

            //对全局异常处理程序自注入
            //container.RegisterType<ExceptionLogAttribute, ExceptionLogAttribute>();

            var conv = new Convention(container,
                typeof(BaseBiz).Assembly,
                typeof(TemplateServiceImpl).Assembly,
                Assembly.GetExecutingAssembly()
                );

            container.RegisterTypes(conv);
        }
Example #50
0
        public static void RegisterTypes(IUnityContainer container)
        {
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default
                );

            container.RegisterType<AccountController>(new InjectionConstructor());

            /*
            container.RegisterType<IApplicationDbContext, ApplicationDbContext>();
            container.RegisterType<IQuestionRepository, QuestionRepository>();
            container.RegisterType<IPostRepository, PostRepository>();
             */
        }
Example #51
0
        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);
        }
Example #52
0
        public static void RegisterTypes(IUnityContainer container)
        {
            var myAssemblies =
                AppDomain.CurrentDomain.GetAssemblies()
                    .Where(a => a.FullName.StartsWith(ClassesToScan))
                    .ToArray();

            container.RegisterTypes(UnityHelpers.GetTypesWithCustomAttribute<UnityIoCPerRequestLifetimeAttribute>(myAssemblies),
                                    WithMappings.FromMatchingInterface,
                                    WithName.Default,
                                    PerRequest
                                )
                     .RegisterTypes(UnityHelpers.GetTypesWithCustomAttribute<UnityIoCTransientLifetimeAttribute>(myAssemblies),
                                    WithMappings.FromMatchingInterface,
                                    WithName.Default,
                                    WithLifetime.Transient
                                );
        }
Example #53
0
        /// <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"));
        }
Example #54
0
        /// <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();

            container.RegisterTypes(AllClasses.FromAssemblies(
                    typeof(ISessionManager).Assembly,
                    typeof(INavigationManager).Assembly,
                    typeof(Users).Assembly,
                    typeof(IUsers).Assembly,
                    typeof(IConfigurationManager).Assembly),
                WithMappings.FromMatchingInterface,
                WithName.Default,
                WithLifetime.ContainerControlled);

            //var allJobRepositories = container.ResolveAll<IJobRepository>();
            //var parameter = new InjectionConstructor(allJobRepositories);
            //container.RegisterType<IJobManager, JobManager>(parameter);
        }
Example #55
0
        public static void RegisterTypes(IUnityContainer container)
        {
            //Register data access components
            container.RegisterType<IDbContextFactory, DbContextFactory>(new PerRequestLifetimeManager());
            container.RegisterType(typeof(IRepository<>), typeof(Repository<>));
            container.RegisterType<IUnitOfWork, UnitOfWork>();

            //Register all files with supporting interface file e.g. IFacilityService and FacilityService
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies(),
                WithMappings.FromMatchingInterface,
                WithName.Default);

            //Validators
            container.RegisterInstance(typeof(IValidationProvider), new ValidationProvider(type => (IValidator)container.Resolve(typeof(Validator<>).MakeGenericType(type))));
            container.RegisterType(typeof(Validator<>), typeof(NullValidator<>));
            container.RegisterType<Validator<Package>, PackageValidator>();
            container.RegisterType<Validator<Maintenance>, MaintenanceValidator>();
            container.RegisterType<Validator<DeploymentSchedule>, DeploymentScheduleValidator>();
        }
Example #56
0
        /// <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)
        {
            var myAssemblies = AppDomain.CurrentDomain.GetAssemblies().Where(a => a.FullName.StartsWith("ServiceLayer")).ToArray();

            container.AddNewExtension<Interception>();
            container.RegisterTypes(RegisterTypesScan.GetTypesWithCustomAttribute<RequestReponseAttribute>(myAssemblies),
                                    WithMappings.FromMatchingInterface,
                                    WithName.Default,
                                    WithLifetime.ContainerControlled,
                                    getInjectionMembers: t => new InjectionMember[]
                                    {
                                        new Interceptor<InterfaceInterceptor>(),
                                        new InterceptionBehavior<MvcApplication1.Logging.RequestResponseBehaviour>()
                                    })
                     .RegisterTypes(RegisterTypesScan.GetTypesWithCustomAttribute<DataAccessAttribute>(myAssemblies),
                                    WithMappings.FromMatchingInterface,
                                    WithName.Default,
                                    WithLifetime.Transient
                                );
        }
Example #57
0
        private void RegisterTypes(IUnityContainer container)
        {
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().Where(
                    t => t.Name.ToLower().Contains("service")),
                WithMappings.FromAllInterfacesInSameAssembly,
                WithName.Default,
                WithLifetime.ContainerControlled);

            container.RegisterType<GameHub>(new InjectionFactory(CreateGameHub));
        }
Example #58
0
        public static void RegisterTypes(IUnityContainer container)
        {
            container.AddNewExtension<Interception>();

            var connectionString =
                System.Web.Configuration.WebConfigurationManager.ConnectionStrings["Mongo"].ConnectionString;
            var database = System.Web.Configuration.WebConfigurationManager.ConnectionStrings["Mongo"].ProviderName;

            container.RegisterType<IMongoConnectionHandler, MongoConnectionHandler>(
                new ContainerControlledLifetimeManager(),
                new InjectionConstructor(connectionString, database));

            // orchestrators
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().Where(
                  t => t.Namespace == "RightpointLabs.Pourcast.Application.Orchestrators.Concrete"),
                WithMappings.FromAllInterfaces,
                WithName.Default,
                WithLifetime.Custom<PerRequestLifetimeManager>,
                getInjectionMembers: t => new InjectionMember[]
                {
                    new InterceptionBehavior<PolicyInjectionBehavior>(),
                    new Interceptor<InterfaceInterceptor>()
                });

            // repositories
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().Where(
                  t => t.Namespace == "RightpointLabs.Pourcast.Infrastructure.Persistence.Repositories"),
                WithMappings.FromAllInterfaces,
                WithName.Default,
                WithLifetime.Custom<PerRequestLifetimeManager>,
                getInjectionMembers: t => new InjectionMember[]
                {
                    new InterceptionBehavior<PolicyInjectionBehavior>(),
                    new Interceptor<InterfaceInterceptor>()
                });
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().Where(
                  t => t.Namespace == "RightpointLabs.Pourcast.Infrastructure.Persistence.Collections"),
                WithMappings.FromAllInterfaces,
                WithName.Default,
                WithLifetime.Custom<ContainerControlledLifetimeManager>);

            // domain services
            container.RegisterType<IEmailService, SmtpEmailService>(new PerRequestLifetimeManager());
            container.RegisterType<IDateTimeProvider, CurrentDateTimeProvider>(new ContainerControlledLifetimeManager());
            container.RegisterType<IMessagePoster, YammerMessagePoster>(new ContainerControlledLifetimeManager(),
                new InjectionConstructor(
                    new InjectionParameter<string>(ConfigurationManager.AppSettings["YammerApiCode"]),
                    new InjectionParameter<int>(int.Parse(ConfigurationManager.AppSettings["YammerGroupId"] ?? "0"))));
            container.RegisterType<IFaceRecognitionService, FaceRecognitionService>(new ContainerControlledLifetimeManager(),
                new InjectionConstructor(
                    new InjectionParameter<string>(ConfigurationManager.AppSettings["SkyBiometryApiKey"]),
                    new InjectionParameter<string>(ConfigurationManager.AppSettings["SkyBiometryApiSecret"]),
                    new InjectionParameter<string>(ConfigurationManager.AppSettings["SkyBiometryTagNamespace"]),
                    typeof(IImageCleanupService),
                    typeof(IOverlayImageProvider)));
            container.RegisterType<IImageCleanupService, ImageCleanupService>(new PerRequestLifetimeManager());

            // StateTracker
            container.RegisterType<StateTracker>(new ContainerControlledLifetimeManager());
            container.RegisterType<IEventHandler<PictureTaken>, StateTracker.StateTrackerEventHandler>("StateTrackerEventHandler_PictureTaken", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PourStopped>, StateTracker.StateTrackerEventHandler>("StateTrackerEventHandler_PourStopped", new PerRequestLifetimeManager());

            // event handlers (must be named!)
            container.RegisterType(typeof(IEventHandler<>), typeof(EventStoreHandler<>), "EventStore", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PourStopped>, KegNearingEmptyNotificationHandler>("KegNearingEmptyNotification", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegRemainingChanged>, KegNearingEmptyNotificationHandler>("KegNearingEmptyNotification", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegEmptied>, KegEmptiedNotificationHandler>("KegEmptiedNotification", new PerRequestLifetimeManager());

            // signalr event handlers (must be named!)
            container.RegisterType<IEventHandler<PourStarted>, PourStartedClientHandler>("BeerPourStartedClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<Pouring>, PouringClientHandler>("BeerPouringClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PourStopped>, PourStoppedClientHandler>("BeerPourStoppedClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegRemainingChanged>, KegRemainingChangedClientHandler>("KegRemainingChangedClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegRemovedFromTap>, KegRemovedFromTapClientHandler>("KegRemovedFromTapClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegTapped>, KegTappedClientHandler>("KegTappedClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegTemperatureChanged>, KegTemperatureChangedClientHandler>("KegTemperatureChangedClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<Heartbeat>, HeartbeatClientHandler>("HeartbeatClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<LogMessage>, LogMessageClientHandler>("LogMessageClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PictureTaken>, PictureTakenClientHandler>("PictureTakenClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PictureRequested>, PictureRequestedClientHandler>("PictureRequestedClientHandler", new PerRequestLifetimeManager());

            // misc
            container.RegisterType<SmtpClient>(new PerRequestLifetimeManager(), new InjectionConstructor());
            container.RegisterType<IConnectionManager>(new ContainerControlledLifetimeManager(), new InjectionFactory(c => GlobalHost.ConnectionManager));

            container.RegisterType<IOverlayImageProvider, OverlayImageProvider>(new ContainerControlledLifetimeManager());

            var locator = new App_Start.UnityServiceLocator(container);
            ServiceLocator.SetLocatorProvider(() => locator);
        }
Example #59
0
        public static void RegisterTypes(IUnityContainer container)
        {
            container.AddNewExtension<Interception>();

            var connectionString =
                System.Web.Configuration.WebConfigurationManager.ConnectionStrings["Mongo"].ConnectionString;
            var database = System.Web.Configuration.WebConfigurationManager.ConnectionStrings["Mongo"].ProviderName;

            container.RegisterType<IMongoConnectionHandler, MongoConnectionHandler>(
                new ContainerControlledLifetimeManager(),
                new InjectionConstructor(connectionString, database));

            // orchestrators
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().Where(
                  t => t.Namespace == "RightpointLabs.Pourcast.Application.Orchestrators.Concrete"),
                WithMappings.FromAllInterfaces,
                WithName.Default,
                WithLifetime.Custom<PerRequestLifetimeManager>,
                getInjectionMembers: t => new InjectionMember[]
                {
                    new InterceptionBehavior<PolicyInjectionBehavior>(),
                    new Interceptor<InterfaceInterceptor>()
                });

            // repositories
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().Where(
                  t => t.Namespace == "RightpointLabs.Pourcast.Infrastructure.Persistence.Repositories"),
                WithMappings.FromAllInterfaces,
                WithName.Default,
                WithLifetime.Custom<PerRequestLifetimeManager>,
                getInjectionMembers: t => new InjectionMember[]
                {
                    new InterceptionBehavior<PolicyInjectionBehavior>(),
                    new Interceptor<InterfaceInterceptor>()
                });
            container.RegisterTypes(
                AllClasses.FromLoadedAssemblies().Where(
                  t => t.Namespace == "RightpointLabs.Pourcast.Infrastructure.Persistence.Collections"),
                WithMappings.FromAllInterfaces,
                WithName.Default,
                WithLifetime.Custom<ContainerControlledLifetimeManager>);

            // domain services
            container.RegisterType<IEmailService, SmtpEmailService>(new PerRequestLifetimeManager());
            container.RegisterType<IDateTimeProvider, CurrentDateTimeProvider>(new ContainerControlledLifetimeManager());

            // event handlers (must be named!)
            container.RegisterType(typeof(IEventHandler<>), typeof(EventStoreHandler<>), "EventStore", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PourStopped>, KegNearingEmptyNotificationHandler>("KegNearingEmptyNotification", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegEmptied>, KegEmptiedNotificationHandler>("KegEmptiedNotification", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PourStarted>, TextFirstPourNotificationHandler>("TextFirstPourNotification", new ContainerControlledLifetimeManager());

            // signalr event handlers (must be named!)
            container.RegisterType<IEventHandler<PourStarted>, PourStartedClientHandler>("BeerPourStartedClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<PourStopped>, PourStoppedClientHandler>("BeerPourStoppedClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegRemovedFromTap>, KegRemovedFromTapClientHandler>("KegRemovedFromTapClientHandler", new PerRequestLifetimeManager());
            container.RegisterType<IEventHandler<KegTapped>, KegTappedClientHandler>("KegTappedClientHandler", new PerRequestLifetimeManager());

            // misc
            container.RegisterType<SmtpClient>(new PerRequestLifetimeManager(), new InjectionConstructor());
            container.RegisterType<IConnectionManager>(new ContainerControlledLifetimeManager(), new InjectionFactory(c => GlobalHost.ConnectionManager));

            var locator = new App_Start.UnityServiceLocator(container);
            ServiceLocator.SetLocatorProvider(() => locator);
        }
 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterTypes(AllClasses.FromLoadedAssemblies(), WithMappings.FromMatchingInterface, WithName.Default, WithLifetime.PerResolve);
 }