C# IUnityContainer.IsRegistered方法代码示例

        /// <summary>
        /// Register Types in Unity Container
        /// </summary>
        /// <remarks>If Unity is not configured in App/Web.config this can be used</remarks>
        public IUnityContainer ConfigureDefaultMappings(IUnityContainer cont)
        {
            if (!cont.IsRegistered<ICache>())
                cont.RegisterType<ICache, QuickCache>();
            if (!cont.IsRegistered<IRootSource>())
                cont.RegisterType<IRootSource, EavSqlStore>();

            // register some Default Constructors
            cont.RegisterType<SqlDataSource>(new InjectionConstructor());
            cont.RegisterType<DataTableDataSource>(new InjectionConstructor());
            return cont;
        }

        public static void Register(IUnityContainer container, Guid containerGuid)
        {
            container.RegisterInstance(typeof(IControllerActivator), new UnityControllerActivator(containerGuid));

            foreach (var type in Assembly.GetExecutingAssembly().GetExportedTypes().
                            Where(x => x.GetInterface(typeof(IController).Name) != null))
            {
                container.RegisterType(type);
            }

            DependencyResolver.SetResolver(
                t => container.IsRegistered(t) ? container.Resolve(t) : null,
                t => container.IsRegistered(t) ? container.ResolveAll(t) : Enumerable.Empty<object>());
        }

 private void RegisterCore(SolrCore core, IUnityContainer container) {
     string connectionId = GetCoreConnectionId(core.Id);
     container.RegisterType<ISolrConnection, SolrConnection>(connectionId, new InjectionConstructor(core.Url));
     if (!container.IsRegistered(typeof (ISolrOperations<>).MakeGenericType(core.DocumentType))) {
         RegisterAll(core, container, isNamed : false);
     }
     RegisterAll(core, container);
 }

        private static void RegisterEntityFrameworkEventBusAndProcessor(IUnityContainer container)
        {
            if (container == null) throw new ArgumentNullException(nameof(container));

            if (!container.IsRegistered<IBusContext>())
            {
                container.RegisterType<IBusContext, BusContext>();
            }
            container.RegisterType<IProcessor, EventProcessor>("EventProcessor");
            container.RegisterType<IEventBus, EventBus>();
        }

    private static void RegisterControllers(IUnityContainer container)
    {
        // Also register all the controller types as transient
        Type[] types = Assembly.GetExecutingAssembly().GetTypes();

        var controllerTypes = types.Where(t => typeof(IController).IsAssignableFrom(t));

        foreach (var t in controllerTypes)
        {
            if (!container.IsRegistered(t))
            {
                container.RegisterType(t);
            }
        }
    }

        /// <summary>
        ///     Setups up the service bus with the given IUnityContainer and registers the types found in the given type provider.
        /// </summary>
        public static BusBuilderConfiguration WithUnityDependencyResolver(this BusBuilderConfiguration configuration, ITypeProvider typeProvider, IUnityContainer unityContainer)
        {
            var dependencyResolver = new UnityDependencyResolver(unityContainer);

            unityContainer.RegisterInstance<IDependencyResolver>(dependencyResolver);
            unityContainer.RegisterInstance<ITypeProvider>(typeProvider);

            foreach (var resolvedType in typeProvider.AllResolvableTypes())
            {
                unityContainer.RegisterType(resolvedType);
            }

            if (!unityContainer.IsRegistered<ILogger>())
            {
                unityContainer.RegisterInstance<ILogger>(new NullLogger());
            }

            return configuration.WithLogger(unityContainer.Resolve<ILogger>()).WithDependencyResolver(dependencyResolver);
        }

        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            var handler = new CachingCallHandlerAttribute
                {
                    RegionName = RegionName,
                    ExpirationTime = ExpirationTime,
                    Policy = Policy
                };

            if ((Policy == null) && (container.IsRegistered<CacheItemPolicy>()))
            {
                handler.Policy = container.Resolve<CacheItemPolicy>();
            }

            return handler;
        }

        private static void RegisterEnumerable(IUnityContainer _container)
        {
            _container.RegisterType
                (
                    typeof (IEnumerable<>),
                    new InjectionFactory
                        (
                        (container, enumerableType, name) =>
                        {
                            Type type = enumerableType.GetGenericArguments().Single();

                            object[] allInstances = container.ResolveAll(type).Concat
                                (
                                    (_container.IsRegistered(type) ||
                                     (type.GetGenericArguments().Length > 0 &&
                                      _container.IsRegistered(type.GetGenericTypeDefinition())))
                                        ? new object[] {container.Resolve(type)}
                                        : new object[] {}
                                ).ToArray();

                            return
                                typeof (Enumerable).
                                    GetMethod("OfType", BindingFlags.Static | BindingFlags.Public).
                                    MakeGenericMethod(new Type[] {type}).
                                    Invoke(null, new object[] {allInstances});
                        }
                        )
                );
        }