C# WebAPI Dependency Configuration

using Autofac;
using Autofac.Integration.WebApi;
using Blacksmith.Core;
using ExampleApp.Api.Auth;
using ExampleApp.Api.Caching;
using ExampleApp.Configuration;
using ExampleApp.Manager.Contests;
using ExampleApp.Manager.Funds;
using ExampleApp.Manager.Paypal;
using ExampleApp.Manager.Points;
using ExampleApp.Manager.UserActions;
using ExampleApp.Manager.Users;
using ExampleApp.Manager.Wordlists;
using ExampleApp.Model.Constants;
using ExampleApp.Model.Models;
using ExampleApp.Model.Models.ActivityLog;
using ExampleApp.Model.Models.Paypal;
using ExampleApp.Model.Models.SportRadar.NFL;
using ExampleApp.Repository;
using ExampleApp.Repository.Mongo;
using System.Reflection;
using System.Web.Http;
using WebApi.OutputCache.V2;


namespace ExampleApp.Api
{
    public static class ApiDependencyConfiguration
    {
        public static Autofac.IContainer Container { get; set; }

        public static void Configure(bool repositoriesReadOnly = false)
        {
            // Build service bus client
            var credentials = IronMQConfiguration.GetConfiguration();
            var ironBus = new Client(credentials.ProjectId, credentials.Token, credentials.Host);

            // Configure logging
            {
                // Get credentials (checks build configuration Debug vs Release)
                var loggingCredentials = LoggingConfiguration.GetLoggingConfiguration();

                // Configure logging provider
                Loggr.Utility.Configuration.UseSettings(new Loggr.Utility.Settings()
                {
                    LogKey = loggingCredentials.LogKey,
                    ApiKey = loggingCredentials.ApiKey
                });
            }

            // Build container
            var builder = new ContainerBuilder();
            {
                /* Register repositories with IOC container */
                //Register controllers
                builder.RegisterApiControllers(Assembly.GetExecutingAssembly());

                // Model Repositories
                var connectionString = DatabaseConfiguration.GetMongoConnectionString();
                builder.Register(c => new MongoRepository.MongoRepository<UserActivityLog>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<ScheduledJob>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<User>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<CacheItem>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<BalanceAccount>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<Rank>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<Contest>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<ContestEntry>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<IPNMessage>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<ForgotPasswordRequest>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<ContestInvite>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<Withdrawal>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<SportsEventsSchedule>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<AthleteImage>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<SportsDataMLBGameOutcome>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<ContestAthletes>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<StatsApiNHLAthlete>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<SportsEventsSchedule>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<FraudRiskFilter>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<AccountCancellation>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<BusinessMetric>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<SportsEventsAthletePerformance>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<ContestLobbyLightweight>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<SportsDataNFLGameStatistics>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<QueueConfiguration>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<MaintenanceIssue>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<SportsEventScheduleMatch>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<ServiceStatus>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<GameOutcomeNHL>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<GameOutcomeNBA>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<StatsApiNBAAthlete>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<StatsApiNHLAthlete>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<SportRadarNFLAthlete>(connectionString)).InstancePerLifetimeScope();
                builder.Register(c => new MongoRepository.MongoRepository<FinancialSummary>(connectionString)).InstancePerLifetimeScope();

                builder.RegisterType<ActivityLogUserActionsRepository>().As<IActivityLogUserActionsRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ScheduledJobsRepository>().As<IScheduledJobsRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<UserRepository>().As<IUserRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<CacheItemsRepository>().As<ICacheItemsRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<BalanceAccountRepository>().As<IBalanceAccountRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<RankRepository>().As<IRankRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ContestRepository>().As<IContestRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ContestEntryRepository>().As<IContestEntryRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<PaypalIPNRepository>().As<IPaypalIPNRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ForgotPasswordRequestRepository>().As<IForgotPasswordRequestRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ContestInviteRepository>().As<IContestInviteRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<WithdrawalRepository>().As<IWithdrawalRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<SportsEventsScheduleRepository>().As<ISportsEventsScheduleRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<AthleteImageRepository>().As<IAthleteImageRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<SportsDataMLBGameOutcomeRepository>().As<ISportsDataMLBGameOutcomeRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ContestAthletesRepository>().As<IContestAthletesRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<StatsApiNHLAthleteRepository>().As<IStatsApiNHLAthleteRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<SportsEventsScheduleRepository>().As<ISportsEventsScheduleRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<FraudRiskFilterRepository>().As<IFraudRiskFilterRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<AccountCancellationRepository>().As<IAccountCancellationRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<BusinessMetricRepository>().As<IBusinessMetricRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<SportsEventsAthletePerformanceRepository>().As<ISportsEventsAthletePerformanceRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ContestLobbyRepository>().As<IContestLobbyRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<SportsDataNFLGameStatisticsRepository>().As<ISportsDataNFLGameStatisticsRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<QueueConfigurationRepository>().As<IQueueConfigurationRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<MaintenanceIssueRepository>().As<IMaintenanceIssueRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<SportsEventScheduleMatchRepository>().As<ISportsEventScheduleMatchRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<ServiceStatusRepository>().As<IServiceStatusRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<GameOutcomeNHLRepository>().As<IGameOutcomeNHLRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<GameOutcomeNBARepository>().As<IGameOutcomeNBARepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<StatsApiNBAAthleteRepository>().As<IStatsApiNBAAthleteRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<StatsApiNHLAthleteRepository>().As<IStatsApiNHLAthleteRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<SportRadarNFLAthleteRepository>().As<ISportRadarNFLAthleteRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();
                builder.RegisterType<FinancialSummaryRepository>().As<IFinancialSummaryRepository>().WithParameter(RepoPropertyNames.RepoReadOnlyParameterName, repositoriesReadOnly).InstancePerRequest();

                // Register the managers
                builder.Register(c => new WordlistsManager(Startup.TracingEnabled)).InstancePerRequest();
                builder.Register(c => new UserActionsActivityLogManager(c.Resolve<IActivityLogUserActionsRepository>(), Startup.TracingEnabled, Startup.LogLocalActivity, Startup.LogIgnoredUserActivity)).InstancePerRequest();
                builder.Register(c => new UsersManager(c.Resolve<IUserRepository>(), Startup.TracingEnabled, c.Resolve<WordlistsManager>(), c.Resolve<IForgotPasswordRequestRepository>())).InstancePerDependency();

                builder.Register(c => new ContestsSearchManager(c.Resolve<IContestRepository>(), c.Resolve<IContestEntryRepository>(), c.Resolve<IContestLobbyRepository>(), c.Resolve<IContestAthletesRepository>(), Startup.TracingEnabled)).InstancePerRequest();
                builder.Register(c => new FundsManager(c.Resolve<IUserRepository>(), c.Resolve<IBalanceAccountRepository>(), c.Resolve<UserActionsActivityLogManager>(), c.Resolve<PointsManager>(), c.Resolve<IPaypalIPNRepository>(), c.Resolve<IWithdrawalRepository>(), Startup.TracingEnabled)).InstancePerRequest();
                builder.Register(c => new PointsManager(c.Resolve<IUserRepository>(), c.Resolve<IRankRepository>(), c.Resolve<UserActionsActivityLogManager>(), Startup.TracingEnabled)).InstancePerRequest();
                builder.Register(c => new PaypalManager(Startup.TracingEnabled)).InstancePerRequest();
                builder.Register(c => new ContestCreationManager(c.Resolve<IContestRepository>(), c.Resolve<ISportsEventsScheduleRepository>(), c.Resolve<IContestAthletesRepository>(), Startup.TracingEnabled)).InstancePerRequest();

                // Register more api specific managers
                builder.RegisterType<AuthManager>().PropertiesAutowired(PropertyWiringOptions.None).InstancePerRequest();

                builder.RegisterType<AuthServerProvider>().PropertiesAutowired(PropertyWiringOptions.None).InstancePerRequest();

                // Register servicebus
                builder.Register(c => ironBus).As<IClient>().SingleInstance();
            }

            var container = builder.Build();
            Container = container;

            // Create the dependency resolver.
            var resolver = new AutofacWebApiDependencyResolver(container);

            // Configure Web API with the dependency resolver.
            GlobalConfiguration.Configuration.DependencyResolver = resolver;

            // Cache provider for WebApi.CacheOutput
            var cache = new MemoryCacheWithRemoveAll();
            GlobalConfiguration.Configuration.CacheOutputConfiguration().RegisterCacheOutputProvider(() => cache);

        }
    }
}