protected override void Load()

in edge-agent/src/Microsoft.Azure.Devices.Edge.Agent.Service/modules/EdgeletModule.cs [95:200]
87 lines of code
3 McCabe index (conditional complexity)

        protected override void Load(ContainerBuilder builder)
        {
            // IModuleClientProvider
            builder.Register(c => new ModuleClientProvider(
                    c.Resolve<ISdkModuleClientProvider>(),
                    this.disableDeviceAnalyticsTelemetry ?
                        Option.None<Task<IRuntimeInfoProvider>>() :
                        Option.Some(c.Resolve<Task<IRuntimeInfoProvider>>()),
                    this.upstreamProtocol,
                    this.proxy,
                    this.productInfo,
                    this.closeOnIdleTimeout,
                    this.idleTimeout,
                    this.useServerHeartbeat))
                .As<IModuleClientProvider>()
                .SingleInstance();

            // IModuleManager
            builder.Register(c => new ModuleManagementHttpClient(this.managementUri, this.apiVersion, Constants.EdgeletClientApiVersion, Option.Some(this.edgeletTimeout)))
                .As<IModuleManager>()
                .As<IIdentityManager>()
                .As<IDeviceManager>()
                .SingleInstance();

            // IModuleIdentityLifecycleManager
            var identityBuilder = new ModuleIdentityProviderServiceBuilder(this.iotHubHostName, this.deviceId);
            builder.Register(c => new ModuleIdentityLifecycleManager(c.Resolve<IIdentityManager>(), identityBuilder, this.workloadUri, this.enableOrphanedIdentityCleanup))
                .As<IModuleIdentityLifecycleManager>()
                .SingleInstance();

            // ICombinedConfigProvider<CombinedDockerConfig>
            builder.Register(
                    async c =>
                    {
                        IConfigSource configSource = await c.Resolve<Task<IConfigSource>>();
                        return new CombinedEdgeletConfigProvider(this.dockerAuthConfig, configSource) as ICombinedConfigProvider<CombinedDockerConfig>;
                    })
                .As<Task<ICombinedConfigProvider<CombinedDockerConfig>>>()
                .SingleInstance();

            // ICommandFactory
            builder.Register(
                    async c =>
                    {
                        var moduleManager = c.Resolve<IModuleManager>();
                        var combinedDockerConfigProviderTask = c.Resolve<Task<ICombinedConfigProvider<CombinedDockerConfig>>>();
                        var configSourceTask = c.Resolve<Task<IConfigSource>>();
                        var metricsProvider = c.Resolve<IMetricsProvider>();
                        var loggerFactory = c.Resolve<ILoggerFactory>();
                        IConfigSource configSource = await configSourceTask;
                        ICombinedConfigProvider<CombinedDockerConfig> combinedDockerConfigProvider = await combinedDockerConfigProviderTask;
                        ICommandFactory factory = new EdgeletCommandFactory<CombinedDockerConfig>(
                            moduleManager,
                            configSource,
                            combinedDockerConfigProvider);

                        if (this.moduleUpdateMode == ModuleUpdateMode.NonBlocking)
                        {
                            factory = new StandardCommandFactory(factory);
                        }
                        else
                        {
                            factory = new ExecutionPrerequisiteCommandFactory(factory);
                        }

                        factory = new MetricsCommandFactory(factory, metricsProvider);
                        return new LoggingCommandFactory(factory, loggerFactory) as ICommandFactory;
                    })
                .As<Task<ICommandFactory>>()
                .SingleInstance();

            // Task<IRuntimeInfoProvider>
            builder.Register(c => Task.FromResult(new RuntimeInfoProvider<DockerReportedConfig>(c.Resolve<IModuleManager>()) as IRuntimeInfoProvider))
                .As<Task<IRuntimeInfoProvider>>()
                .SingleInstance();

            // Task<IEnvironmentProvider>
            builder.Register(
                    async c =>
                    {
                        var moduleStateStore = await c.Resolve<Task<IEntityStore<string, ModuleState>>>();
                        var restartPolicyManager = c.Resolve<IRestartPolicyManager>();
                        IRuntimeInfoProvider runtimeInfoProvider = await c.Resolve<Task<IRuntimeInfoProvider>>();
                        IEnvironmentProvider dockerEnvironmentProvider = await DockerEnvironmentProvider.CreateAsync(runtimeInfoProvider, moduleStateStore, restartPolicyManager, CancellationToken.None);
                        return dockerEnvironmentProvider;
                    })
                .As<Task<IEnvironmentProvider>>()
                .SingleInstance();

            // Task<IBackupSource>
            builder.Register(
                async c =>
                {
                    var serde = c.Resolve<ISerde<DeploymentConfigInfo>>();
                    var encryptionProviderTask = c.Resolve<Task<IEncryptionProvider>>();
                    IDeploymentBackupSource backupSource = new DeploymentFileBackup(this.backupConfigFilePath, serde, await encryptionProviderTask);
                    return backupSource;
                })
                .As<Task<IDeploymentBackupSource>>()
                .SingleInstance();

            // SystemResourcesMetrics
            builder.Register(c => new SystemResourcesMetrics(c.Resolve<IMetricsProvider>(), c.Resolve<IModuleManager>().GetSystemResourcesAsync, this.apiVersion, this.performanceMetricsUpdateFrequency))
                .As<ISystemResourcesMetrics>()
                .SingleInstance();
        }