C# IDependencyResolver.Register方法代码示例

        public static void RegisterDefaultServices(IDependencyResolver resolver) {
            var fileStorage = new Lazy<IFileStorage>(() => resolver.Resolve<InMemoryFileStorage>());
            resolver.Register(typeof(IFileStorage), () => fileStorage.Value);

            var exceptionlessLog = new Lazy<IExceptionlessLog>(() => resolver.Resolve<NullExceptionlessLog>());
            resolver.Register(typeof(IExceptionlessLog), () => exceptionlessLog.Value);

            var jsonSerializer = new Lazy<IJsonSerializer>(() => resolver.Resolve<DefaultJsonSerializer>());
            resolver.Register(typeof(IJsonSerializer), () => jsonSerializer.Value);

            var eventQueue = new Lazy<IEventQueue>(() => resolver.Resolve<DefaultEventQueue>());
            resolver.Register(typeof(IEventQueue), () => eventQueue.Value);

            var submissionClient = new Lazy<ISubmissionClient>(() => resolver.Resolve<DefaultSubmissionClient>());
            resolver.Register(typeof(ISubmissionClient), () => submissionClient.Value);

            var environmentInfoCollector = new Lazy<IEnvironmentInfoCollector>(() => resolver.Resolve<DefaultEnvironmentInfoCollector>());
            resolver.Register(typeof(IEnvironmentInfoCollector), () => environmentInfoCollector.Value);

            var lastClientIdManager = new Lazy<ILastReferenceIdManager>(() => resolver.Resolve<DefaultLastReferenceIdManager>());
            resolver.Register(typeof(ILastReferenceIdManager), () => lastClientIdManager.Value);

            var duplicateChecker = new Lazy<IDuplicateChecker>(() => resolver.Resolve<DefaultDuplicateChecker>());
            resolver.Register(typeof(IDuplicateChecker), () => duplicateChecker.Value);

            var persistedClientData = new Lazy<PersistedDictionary>(() => new PersistedDictionary("client-data.json", resolver.Resolve<IFileStorage>(), resolver.Resolve<IJsonSerializer>()));
            resolver.Register(typeof(PersistedDictionary), () => persistedClientData.Value);
        }

        protected void UseMessageBus(MessageBusType type, IDependencyResolver resolver, int streams = 1)
        {
            IMessageBus bus = null;

            switch (type)
            {
                case MessageBusType.Default:
                    break;
                case MessageBusType.Fake:
                case MessageBusType.FakeMultiStream:
                    bus = new FakeScaleoutBus(resolver, streams);
                    break;
                case MessageBusType.SqlServer:
                    break;
                case MessageBusType.ServiceBus:
                    break;
                case MessageBusType.Redis:
                    break;
                default:
                    break;
            }

            if (bus != null)
            {
                resolver.Register(typeof(IMessageBus), () => bus);
            }
        }

        public static void RegisterDependencies(IDependencyResolver dependencyResolver, SqlDatabaseTypeEnum databaseType)
        {
            dependencyResolver.Register<IUnitOfWorkFactory, EntityFrameworkUnitOfWorkFactory>();

            if (databaseType == SqlDatabaseTypeEnum.Azure)
            {
                dependencyResolver.Register<IDbConfiguration, SqlDatabaseConfiguration>();
                DbConfiguration.SetConfiguration(new SqlDatabaseConfiguration());
            }
            else
            {
                dependencyResolver.Register<IDbConfiguration, NullDatabaseConfiguration>();
                DbConfiguration.SetConfiguration(new NullDatabaseConfiguration());
            }

            dependencyResolver.Register<IUnitOfWorkFactoryProvider, EntityFrameworkUnitOfWorkFactoryProvider>();
        }

        /// <summary>
        /// Register the PayloadCompressionModule and all required dependency resolver pieces.
        /// </summary>
        public void CompressPayloads(IDependencyResolver resolver)
        {
            var payloadDescriptorProvider = new Lazy<ReflectedPayloadDescriptorProvider>(() => new ReflectedPayloadDescriptorProvider(resolver));
            resolver.Register(typeof(IPayloadDescriptorProvider), () => payloadDescriptorProvider.Value);

            var payloadCompressor = new Lazy<DefaultPayloadCompressor>(() => new DefaultPayloadCompressor(resolver));
            resolver.Register(typeof(IPayloadCompressor), () => payloadCompressor.Value);

            var payloadDecompressor = new Lazy<DefaultPayloadDecompressor>(() => new DefaultPayloadDecompressor(resolver));
            resolver.Register(typeof(IPayloadDecompressor), () => payloadDecompressor.Value);

            var contractGenerator = new Lazy<DefaultContractsGenerator>(() => new DefaultContractsGenerator(resolver));
            resolver.Register(typeof(IContractsGenerator), () => contractGenerator.Value);

            var parameterBinder = new Lazy<CompressableParameterResolver>(() => new CompressableParameterResolver(payloadDescriptorProvider.Value, payloadDecompressor.Value));
            resolver.Register(typeof(IParameterResolver), () => parameterBinder.Value);

            resolver.Resolve<IHubPipeline>().AddModule(new PayloadCompressionModule(resolver.Resolve<IPayloadCompressor>(), resolver.Resolve<IPayloadDescriptorProvider>(), resolver.Resolve<IContractsGenerator>()));
        }

        private static IDependencyResolver RegisterBus(IDependencyResolver resolver, RabbitMqScaleoutConfiguration configuration, RabbitConnectionBase advancedConnectionInstance = null)
        {
            RabbitMqMessageBus bus = null;
            var initialized = false;
            var syncLock = new object();
            Func<RabbitMqMessageBus> busFactory = () => new RabbitMqMessageBus(resolver, configuration, advancedConnectionInstance);

            resolver.Register(typeof (IMessageBus), () => LazyInitializer.EnsureInitialized(ref bus, ref initialized, ref syncLock, busFactory));
            
            return resolver;
        }

 protected void UseMessageBus(MessageBusType type, IDependencyResolver resolver, ScaleoutConfiguration configuration = null, int streams = 1)
 {
     switch (type)
     {
         case MessageBusType.Default:
             break;
         case MessageBusType.Fake:
             var bus = new FakeScaleoutBus(resolver, streams);
             resolver.Register(typeof(IMessageBus), () => bus);
             break;
         case MessageBusType.SqlServer:
             break;
         case MessageBusType.ServiceBus:
             break;
         case MessageBusType.Redis:
             break;
         default:
             break;
     }
 }

        public static void RegisterDependencies(IDependencyResolver dependencyResolver,
            bool forceAppConfig,
            bool useAzureSqlDatabaseConfiguration,
            bool useLegacyQueueSerializer,
            bool registerEmailAlertSender)
        {
            // internal
            dependencyResolver.Register<ITableStorageQueryBuilder, TableStorageQueryBuilder>();
            dependencyResolver.Register<ITableContinuationTokenSerializer, TableContinuationTokenSerializer>();
            if (useLegacyQueueSerializer)
            {
                dependencyResolver.Register<IQueueSerializer, LegacyQueueSerializer>();
            }
            else
            {
                dependencyResolver.Register<IQueueSerializer, QueueSerializer>();
            }

            // configuration
            dependencyResolver.RegisterInstance<IConfiguration>(new Configuration.Configuration(forceAppConfig));

            // policies            
            dependencyResolver.Register<ILeaseManagerFactory, LeaseManagerFactory>();

            // runtime
            dependencyResolver.Register<IRuntimeEnvironment, RuntimeEnvironment>();
            
            // repositories and data storage
            dependencyResolver.Register<IQueueFactory, QueueFactory>();
            dependencyResolver.Register<IBlobRepositoryFactory, BlobRepositoryFactory>();
            dependencyResolver.Register<ITableStorageRepositoryFactory, TableStorageRepositoryFactory>();
            dependencyResolver.Register<ITableStorageConcurrencyManager, TableStorageConcurrencyManager>();

            // alerts
            if (registerEmailAlertSender)
            {
                dependencyResolver.Register<IAlertSender, AlertSender>();
            }
            else
            {
                dependencyResolver.Register<IAlertSender, NullAlertSender>();
            }

            dependencyResolver.Register<IAzureApplicationResourceFactory, AzureApplicationResourceFactory>();
        }        

            public ServerNode(IMessageBus bus)
            {
                // Give each server it's own dependency resolver
                Server = new MemoryHost();
                Resolver = new DefaultDependencyResolver();

                Resolver.Register(typeof(FarmConnection), () => new FarmConnection());
                Resolver.Register(typeof(IMessageBus), () => bus);

                var context = Resolver.Resolve<IConnectionManager>().GetConnectionContext<FarmConnection>();
                _connection = context.Connection;
            }

        public virtual void Initialize(int? keepAlive = -1,
                                       int? connectionTimeout = 110,
                                       int? disconnectTimeout = 30,
                                       int? transportConnectTimeout = 5,
                                       int? maxIncomingWebSocketMessageSize = 64 * 1024,
                                       bool enableAutoRejoiningGroups = false,
                                       MessageBusType type = MessageBusType.Default)
        {
            Resolver = Resolver ?? new DefaultDependencyResolver();

            _traceManager = Resolver.Resolve<ITraceManager>();
            _traceManager.Switch.Level = SourceLevels.Verbose;

            foreach (var sourceName in _traceSources)
            {
                TraceSource source = _traceManager[sourceName];
                source.Listeners.Add(_listener);
            }

            var configuration = Resolver.Resolve<IConfigurationManager>();

            if (connectionTimeout != null)
            {
                configuration.ConnectionTimeout = TimeSpan.FromSeconds(connectionTimeout.Value);
            }

            if (disconnectTimeout != null)
            {
                configuration.DisconnectTimeout = TimeSpan.FromSeconds(disconnectTimeout.Value);
            }

            if (transportConnectTimeout != null)
            {
                configuration.TransportConnectTimeout = TimeSpan.FromSeconds(transportConnectTimeout.Value);
            }

            configuration.MaxIncomingWebSocketMessageSize = maxIncomingWebSocketMessageSize;

            if (!keepAlive.HasValue)
            {
                configuration.KeepAlive = null;
            }
            // Set only if the keep-alive was changed from the default value.
            else if (keepAlive.Value != -1)
            {
                configuration.KeepAlive = TimeSpan.FromSeconds(keepAlive.Value);
            }

            IMessageBus bus = null;

            switch (type)
            {
                case MessageBusType.Default:
                    break;
                case MessageBusType.Fake:
                    bus = new FakeScaleoutBus(Resolver, streams: 1);
                    break;
                case MessageBusType.FakeMultiStream:
                    bus =  new FakeScaleoutBus(Resolver, streams: 3);
                    break;
                default:
                    throw new NotImplementedException();
            }

            if (bus != null)
            {
                Resolver.Register(typeof(IMessageBus), () => bus);
            }
        }