C# IRegistry.Register方法代码示例

		private static void SetupExtensibility(IRegistry registry)
		{
			var dynamicProxy = new CastleDynamicProxyProvider();
			var aopRepository = new AspectRepository(dynamicProxy);

			var dllPlugins =
				(from key in ConfigurationManager.AppSettings.AllKeys
				 where key.StartsWith("PluginsPath", StringComparison.OrdinalIgnoreCase)
				 let path = ConfigurationManager.AppSettings[key]
				 let pathRelative = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path)
				 let chosenPath = Directory.Exists(pathRelative) ? pathRelative : path
				 select chosenPath)
				.ToList();
			registry.RegisterInstance(new PluginsConfiguration { Directories = dllPlugins });

			registry.Register<SystemInitialization>();
			registry.Register<IObjectFactory, DryIocObjectFactory>(Reuse.Singleton);
			registry.Register<IExtensibilityProvider, DryIocMefProvider>(Reuse.Singleton);
			registry.Register(typeof(IPluginRepository<>), typeof(PluginRepository<>), Reuse.Singleton);

			registry.RegisterInstance<IAspectRegistrator>(aopRepository);
			registry.RegisterInstance<IAspectComposer>(aopRepository);
			//registry.RegisterInstance<IInterceptorRegistrator>(aopRepository);
			registry.RegisterInstance<IMixinProvider>(dynamicProxy);
			registry.RegisterInstance<IDynamicProxyProvider>(dynamicProxy);
		}

 private static void RegisterStandard(IRegistry registry)
 {
     registry.Register<Singleton1>().As<ISingleton1>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<Transient1>().As<ITransient1>().WithLifetime(Lifetime.Transient);
     registry.Register<Combined1>().As<ICombined1>().WithLifetime(Lifetime.Transient)
         .UsingConstructor()
         .WithResolvedParameter<ISingleton1>()
         .WithResolvedParameter<ITransient1>()
         .AsLastParameter();
 }

 private static void RegisterDummies(IRegistry registry)
 {
     registry.Register<DummyOne>().As<IDummyOne>().WithLifetime(Lifetime.Transient);
     registry.Register<DummyTwo>().As<IDummyTwo>().WithLifetime(Lifetime.Transient);
     registry.Register<DummyThree>().As<IDummyThree>().WithLifetime(Lifetime.Transient);
     registry.Register<DummyFour>().As<IDummyFour>().WithLifetime(Lifetime.Transient);
     registry.Register<DummyFive>().As<IDummyFive>().WithLifetime(Lifetime.Transient);
     registry.Register<DummySix>().As<IDummySix>().WithLifetime(Lifetime.Transient);
     registry.Register<DummySeven>().As<IDummySeven>().WithLifetime(Lifetime.Transient);
     registry.Register<DummyEight>().As<IDummyEight>().WithLifetime(Lifetime.Transient);
     registry.Register<DummyNine>().As<IDummyNine>().WithLifetime(Lifetime.Transient);
     registry.Register<DummyTen>().As<IDummyTen>().WithLifetime(Lifetime.Transient);
 }

 private static void RegisterComplex(IRegistry registry)
 {
     registry.Register<SubObjectOne>().As<ISubObjectOne>().WithLifetime(Lifetime.Transient);
     registry.Register<SubObjectTwo>().As<ISubObjectTwo>().WithLifetime(Lifetime.Transient);
     registry.Register<SubObjectThree>().As<ISubObjectThree>().WithLifetime(Lifetime.Transient);
     registry.Register<FirstService>().As<IFirstService>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<SecondService>().As<ISecondService>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<ThirdService>().As<IThirdService>().WithLifetime(Lifetime.Container).PreCreateInstance();
     registry.Register<Complex1>().As<IComplex1>().WithLifetime(Lifetime.Transient);
 }

		public static void Load(IRegistry registry)
		{
			registry.RegisterInstance<ISystemState>(new ServerState());
			registry.RegisterInstance<IPermissionManager>(new NoAuth());

			registry.Register<IRestApplication, RestApplication>(Reuse.Singleton);
			registry.Register<RestApplication>(Reuse.Singleton);
			//builder.RegisterType<SoapApplication>().As<SoapApplication, ISoapApplication>();
			registry.Register<ICommandConverter, CommandConverter>(Reuse.Singleton);

			SetupExtensibility(registry);
			SetupPostgres(registry);
			SetupPatterns(registry);
			SetupSerialization(registry);

			//builder.RegisterType<RepositoryAuthentication>().As<IAuthentication>();
			//builder.RegisterType<RepositoryPrincipalFactory>().As<IPrincipalFactory>();
			//registry.Register<IPermissionManager, PermissionManager>(Reuse.Singleton);

			registry.Register<IProcessingEngine, ProcessingEngine>(Reuse.Singleton);
			registry.Register<IScopePool, ScopePool>(Reuse.Singleton);
		}

 internal static void RegisterIoC(IRegistry registry)
 {
     registry.Register<ICodeLocationRepository>(new CodeLocationRepository());
     registry.Register<IApiDataRepository>(new ApiDataRepository());
     registry.Register<IJobRepository>(new JobRepository());
     registry.Register<IWorkerRepository>(new WorkerRepository());
     registry.Register<IFileRepository>(new FileRepository());
     registry.Register<IRepositoryController>(new RepositoryController());
 }

        public static void Load(IRegistry registry)
        {
            registry.Register<IRestApplication, RestApplication>(Reuse.Singleton);
            registry.Register<RestApplication>(Reuse.Singleton);
            //builder.RegisterType<SoapApplication>().As<SoapApplication, ISoapApplication>();
            registry.Register<ICommandConverter, CommandConverter>(Reuse.Singleton);

            SetupExtensibility(registry);
            SetupPostgres(registry);
            SetupPatterns(registry);
            SetupSerialization(registry);

            //builder.RegisterType<RepositoryAuthentication>().As<IAuthentication>();
            //builder.RegisterType<RepositoryPrincipalFactory>().As<IPrincipalFactory>();
            registry.Register<IPermissionManager, PermissionManager>(Reuse.Singleton);

            registry.Register<ILogFactory, LogFactory>(Reuse.Singleton);
            registry.Register<ILogger, NLogLogger>();
            registry.Register<IProcessingEngine, ProcessingEngine>(Reuse.Singleton);
        }

        private static void SetupPatterns(IRegistry registry)
        {
            var serverModels =
                (from key in ConfigurationManager.AppSettings.AllKeys
                 where key.StartsWith("ServerAssembly", StringComparison.OrdinalIgnoreCase)
                 select LoadAssembly(ConfigurationManager.AppSettings[key]))
                .ToList();

            if (serverModels.Count == 0)
            {
                serverModels =
                    (from asm in NGS.Utility.AssemblyScanner.GetAssemblies()
                     let type = asm.GetType("SystemBoot.Configuration")
                     where type != null && type.GetMethod("Initialize") != null
                     select asm)
                    .ToList();
                if (serverModels.Count == 0)
                    throw new ConfigurationErrorsException(@"Server assemblies not found. When running in compiled mode, server assemblies must be deployed with other assemblies.
            Alternatively, explicitly specify sever assembly in the config file.
            Example: <add key=""ServerAssembly_Domain"" value=""AppDomainModel.dll"" />");
            }

            registry.RegisterDelegate<IDomainModel>(c => new NGS.DomainPatterns.DomainModel(serverModels, c.Resolve<IObjectFactory>()), Reuse.Singleton);
            registry.Register<ITypeResolver, DomainTypeResolver>(Reuse.Singleton);
            registry.Register<IServiceLocator, ServiceLocator>(Reuse.InCurrentScope);
            registry.Register<IServiceProvider, ServiceLocator>(Reuse.InCurrentScope);
            registry.Register(typeof(IDataCache<>), typeof(WeakCache<>), Reuse.InCurrentScope);
            registry.Register<IDomainEventSource, DomainEventSource>(Reuse.InCurrentScope);
            registry.Register<IDomainEventStore, DomainEventStore>(Reuse.InCurrentScope);
            registry.Register(typeof(IDomainEventSource<>), typeof(SingleDomainEventSource<>), Reuse.InCurrentScope);
            registry.Register(typeof(RegisterChangeNotifications<>), typeof(IObservable<>), Reuse.Singleton);
        }

 private static void SetupSerialization(IRegistry registry)
 {
     registry.Register<GenericDataContractResolver>(Reuse.Singleton);
     registry.Register<ISerialization<XElement>, XmlSerialization>(Reuse.Singleton);
     registry.Register<GenericDeserializationBinder>(Reuse.Singleton);
     registry.Register<ISerialization<byte[]>, BinarySerialization>(Reuse.Singleton);
     registry.Register<ISerialization<string>, JsonSerialization>(Reuse.Singleton);
     registry.Register<ISerialization<StringBuilder>, JsonSerialization>(Reuse.Singleton);
     registry.Register<ISerialization<StreamReader>, JsonSerialization>(Reuse.Singleton);
     registry.Register<ISerialization<MemoryStream>, ProtobufSerialization>(Reuse.Singleton);
     registry.Register<ISerialization<Stream>, ProtobufSerialization>(Reuse.Singleton);
     registry.Register<ISerialization<object>, PassThroughSerialization>(Reuse.Singleton);
     registry.Register<IWireSerialization, WireSerialization>(Reuse.Singleton);
 }

        private static void SetupPostgres(IRegistry registry)
        {
            var cs = ConfigurationManager.AppSettings["ConnectionString"];
            if (string.IsNullOrEmpty(cs))
                throw new ConfigurationErrorsException(@"ConnectionString is missing from configuration. Add ConnectionString to <appSettings>
            Example: <add key=""ConnectionString"" value=""server=postgres.localhost;port=5432;database=MyDatabase;user=postgres;password=123456;encoding=unicode"" />");

            registry.RegisterInstance(new NGS.DatabasePersistence.Postgres.ConnectionInfo(cs));
            registry.Register<IDatabaseQueryManager, PostgresQueryManager>(Reuse.InCurrentScope);
            registry.Register<IPostgresDatabaseQuery, PostgresDatabaseQuery>();
            registry.RegisterDelegate(r => r.Resolve<IDatabaseQueryManager>().CreateQuery(), Reuse.InCurrentScope);
            registry.Register<IDataChangeNotification, PostgresDatabaseNotification>(Reuse.Singleton);
            registry.Register<IEagerNotification, PostgresDatabaseNotification>(Reuse.Singleton);

            registry.Register<IPostgresConverterRepository, PostgresObjectFactory>(Reuse.Singleton);
            registry.Register<IPostgresConverterFactory, PostgresObjectFactory>(Reuse.Singleton);

            registry.Register<NGS.DatabasePersistence.Postgres.QueryGeneration.QueryExecutor>();
        }

        public static void Default(IRegistry registry)
        {
            registry.ResolutionRules.UnregisteredServices =
                registry.ResolutionRules.UnregisteredServices.Append(
                    ResolveEnumerableAsStaticArray,
                    ResolveManyDynamically);

            var funcFactory = new FactoryProvider(
                (_, __) => new DelegateFactory(GetFuncExpression, Reuse.Singleton),
                GenericWrapperSetup.With(t => t[t.Length - 1]));
            foreach (var funcType in FuncTypes)
                registry.Register(funcType, funcFactory);

            var lazyFactory = new ReflectionFactory(typeof(Lazy<>),
                getConstructor: t => t.GetConstructor(new[] { typeof(Func<>).MakeGenericType(t.GetGenericArguments()) }),
                setup: GenericWrapperSetup.Default);
            registry.Register(typeof(Lazy<>), lazyFactory);

            var metaFactory = new FactoryProvider(GetMetaFactoryOrDefault, GenericWrapperSetup.With(t => t[0]));
            registry.Register(typeof(Meta<,>), metaFactory);

            var debugExprFactory = new FactoryProvider(
                (_, __) => new DelegateFactory(GetDebugExpression),
                GenericWrapperSetup.Default);
            registry.Register(typeof(DebugExpression<>), debugExprFactory);
        }