protected override void Load()

in edge-hub/core/src/Microsoft.Azure.Devices.Edge.Hub.Service/modules/MqttModule.cs [49:148]
85 lines of code
3 McCabe index (conditional complexity)

        protected override void Load(ContainerBuilder builder)
        {
            // IByteBufferAllocator
            builder.Register(
                    c =>
                    {
                        var usePooledBuffers = this.mqttSettingsConfiguration.GetValue("UsePooledBuffers", false);
                        return usePooledBuffers ? PooledByteBufferAllocator.Default : UnpooledByteBufferAllocator.Default as IByteBufferAllocator;
                    })
                .As<IByteBufferAllocator>()
                .SingleInstance();

            builder.Register(c => new ByteBufferConverter(c.Resolve<IByteBufferAllocator>()))
                .As<IByteBufferConverter>()
                .SingleInstance();

            // MessageAddressConverter
            builder.Register(c => new MessageAddressConverter(this.conversionConfiguration))
                .As<MessageAddressConverter>()
                .SingleInstance();

            // IMessageConverter<IProtocolGatewayMessage>
            builder.Register(c => new ProtocolGatewayMessageConverter(c.Resolve<MessageAddressConverter>(), c.Resolve<IByteBufferConverter>()))
                .As<IMessageConverter<IProtocolGatewayMessage>>()
                .SingleInstance();

            // ISettingsProvider
            builder.Register(c => new MqttSettingsProvider(this.mqttSettingsConfiguration))
                .As<ISettingsProvider>()
                .SingleInstance();

            // Task<IMqttConnectionProvider>
            builder.Register(
                    async c =>
                    {
                        var pgMessageConverter = c.Resolve<IMessageConverter<IProtocolGatewayMessage>>();
                        var byteBufferConverter = c.Resolve<IByteBufferConverter>();
                        IConnectionProvider connectionProvider = await c.Resolve<Task<IConnectionProvider>>();
                        ISessionStatePersistenceProvider sessionStatePersistenceProvider = await c.Resolve<Task<ISessionStatePersistenceProvider>>();
                        IMqttConnectionProvider mqtt = new MqttConnectionProvider(connectionProvider, pgMessageConverter, byteBufferConverter, sessionStatePersistenceProvider);
                        return mqtt;
                    })
                .As<Task<IMqttConnectionProvider>>()
                .SingleInstance();

            // Task<ISessionStatePersistenceProvider>
            builder.Register(
                    async c =>
                    {
                        if (this.isStoreAndForwardEnabled)
                        {
                            IDbStoreProvider dbStoreProvider = await c.Resolve<Task<IDbStoreProvider>>();
                            IEntityStore<string, SessionState> entityStore = new StoreProvider(dbStoreProvider).GetEntityStore<string, SessionState>(Constants.SessionStorePartitionKey);
                            IEdgeHub edgeHub = await c.Resolve<Task<IEdgeHub>>();
                            return new SessionStateStoragePersistenceProvider(edgeHub, entityStore) as ISessionStatePersistenceProvider;
                        }
                        else
                        {
                            IEdgeHub edgeHub = await c.Resolve<Task<IEdgeHub>>();
                            return new SessionStatePersistenceProvider(edgeHub) as ISessionStatePersistenceProvider;
                        }
                    })
                .As<Task<ISessionStatePersistenceProvider>>()
                .SingleInstance();

            // MqttProtocolHead
            builder.Register(
                    async c =>
                    {
                        var metadataStore = await c.Resolve<Task<IMetadataStore>>();
                        var settingsProvider = c.Resolve<ISettingsProvider>();
                        var websocketListenerRegistry = c.Resolve<IWebSocketListenerRegistry>();
                        var byteBufferAllocator = c.Resolve<IByteBufferAllocator>();
                        var mqttConnectionProviderTask = c.Resolve<Task<IMqttConnectionProvider>>();
                        var sessionStatePersistenceProviderTask = c.Resolve<Task<ISessionStatePersistenceProvider>>();
                        var authenticatorProviderTask = c.Resolve<Task<IAuthenticator>>();
                        var usernameParser = c.Resolve<IUsernameParser>();
                        IClientCredentialsFactory clientCredentialsProvider = c.Resolve<IClientCredentialsFactory>();
                        IMqttConnectionProvider mqttConnectionProvider = await mqttConnectionProviderTask;
                        ISessionStatePersistenceProvider sessionStatePersistenceProvider = await sessionStatePersistenceProviderTask;
                        IAuthenticator authenticator = await authenticatorProviderTask;
                        return new MqttProtocolHead(
                            settingsProvider,
                            this.tlsCertificate,
                            mqttConnectionProvider,
                            authenticator,
                            usernameParser,
                            clientCredentialsProvider,
                            sessionStatePersistenceProvider,
                            websocketListenerRegistry,
                            byteBufferAllocator,
                            metadataStore,
                            this.clientCertAuthAllowed,
                            this.sslProtocols);
                    })
                .As<Task<MqttProtocolHead>>()
                .SingleInstance();

            base.Load(builder);
        }