protected CommonScriptEngine(IScriptHostFactory scriptHostFactory, ILogProvider logProvider)
 {
     Guard.AgainstNullArgument("logProvider", logProvider);
     ScriptOptions = new ScriptOptions().WithReferences(typeof(Object).Assembly);
     _scriptHostFactory = scriptHostFactory;
     _log = logProvider.ForCurrentType();
 }

        public ExecuteReplCommand(
            string scriptName,
            string[] scriptArgs,
            IFileSystem fileSystem,
            IScriptPackResolver scriptPackResolver,
            IRepl repl,
            ILogProvider logProvider,
            IConsole console,
            IAssemblyResolver assemblyResolver,
            IFileSystemMigrator fileSystemMigrator,
            IScriptLibraryComposer composer)
        {
            Guard.AgainstNullArgument("fileSystem", fileSystem);
            Guard.AgainstNullArgument("scriptPackResolver", scriptPackResolver);
            Guard.AgainstNullArgument("repl", repl);
            Guard.AgainstNullArgument("logProvider", logProvider);
            Guard.AgainstNullArgument("console", console);
            Guard.AgainstNullArgument("assemblyResolver", assemblyResolver);
            Guard.AgainstNullArgument("fileSystemMigrator", fileSystemMigrator);
            Guard.AgainstNullArgument("composer", composer);

            _scriptName = scriptName;
            _scriptArgs = scriptArgs;
            _fileSystem = fileSystem;
            _scriptPackResolver = scriptPackResolver;
            _repl = repl;
            _logger = logProvider.ForCurrentType();
            _console = console;
            _assemblyResolver = assemblyResolver;
            _fileSystemMigrator = fileSystemMigrator;
            _composer = composer;
        }

 public ApplicationInitialization(
     ILogProvider logProvider,
     IPluginsContainer<IServerInitializer> initializersContainer)
 {
     _deployPackagesLogger = logProvider.GetLogger("DeployPackages");
     _initializersContainer = initializersContainer;
 }

 public DslModel(IDslParser dslParser, ILogProvider logProvider)
 {
     _dslParser = dslParser;
     _performanceLogger = logProvider.GetLogger("Performance");
     _logger = logProvider.GetLogger("DslModel");
     _dslContainer = new DslContainer(logProvider);
 }

        public ScriptExecutor(
            IFileSystem fileSystem,
            IFilePreProcessor filePreProcessor,
            IScriptEngine scriptEngine,
            ILogProvider logProvider,
            IScriptLibraryComposer composer)
        {
            Guard.AgainstNullArgument("fileSystem", fileSystem);
            Guard.AgainstNullArgumentProperty("fileSystem", "BinFolder", fileSystem.BinFolder);
            Guard.AgainstNullArgumentProperty("fileSystem", "DllCacheFolder", fileSystem.DllCacheFolder);
            Guard.AgainstNullArgument("filePreProcessor", filePreProcessor);
            Guard.AgainstNullArgument("scriptEngine", scriptEngine);
            Guard.AgainstNullArgument("logProvider", logProvider);
            Guard.AgainstNullArgument("composer", composer);

            References = new AssemblyReferences(DefaultReferences);
            Namespaces = new Collection<string>();
            ImportNamespaces(DefaultNamespaces);
            FileSystem = fileSystem;
            FilePreProcessor = filePreProcessor;
            ScriptEngine = scriptEngine;
            _log = logProvider.ForCurrentType();
#pragma warning disable 618
            Logger = new ScriptCsLogger(_log);
#pragma warning restore 618
            ScriptLibraryComposer = composer;
        }

 public CompileOnlyOptionFilePreProcessor(
     IFileSystem fileSystem,
     ILogProvider logProvider,
     IEnumerable<ILineProcessor> lineProcessors)
     : base(fileSystem, logProvider, lineProcessors)
 {
 }

        public ModuleLoader(IAssemblyResolver resolver, ILogProvider logProvider, Action<Assembly, AggregateCatalog> addToCatalog, Func<CompositionContainer, IEnumerable<Lazy<IModule, IModuleMetadata>>> getLazyModules, IFileSystem fileSystem, IAssemblyUtility assemblyUtility)
        {
            Guard.AgainstNullArgument("logProvider", logProvider);

            _resolver = resolver;
            _logger = logProvider.ForCurrentType();

            if (addToCatalog == null)
            {
                addToCatalog = (assembly, catalog) =>
                {
                    try
                    {
                        var assemblyCatalog = new AssemblyCatalog(assembly);
                        catalog.Catalogs.Add(assemblyCatalog);
                    }
                    catch (Exception exception)
                    {
                        _logger.DebugFormat("Module Loader exception: {0}", exception.Message);
                    }
                };
            }

            _addToCatalog = addToCatalog;

            if (getLazyModules == null)
            {
                getLazyModules = container => container.GetExports<IModule, IModuleMetadata>();
            }

            _getLazyModules = getLazyModules;
            _fileSystem = fileSystem;
            _assemblyUtility = assemblyUtility;
        }

 public Proxy(ILogProvider logProvider, ProxySettings settings)
 {
     LogProvider = logProvider;
     Settings = settings;
     LocalReader = new PacketReader(PacketContext.ClientToServer);
     RemoteReader = new PacketReader(PacketContext.ServerToClient);
 }

 protected DesktopMonitorBaseViewModel(ILogProvider logProvider)
 {
     if (!IsInDesignMode)
     {
         Log = logProvider.GetLogger(GetType());
     }
 }

 public DslParser(IDslSource dslSource, IConceptInfo[] conceptInfoPlugins, ILogProvider logProvider)
 {
     _dslSource = dslSource;
     _conceptInfoPlugins = conceptInfoPlugins;
     _performanceLogger = logProvider.GetLogger("Performance");
     _logger = logProvider.GetLogger("DslParser");
 }

        public WatchScriptCommand(
            Config config,
            string[] scriptArgs,
            IConsole console,
            IFileSystem fileSystem,
            ILogProvider logProvider,
            IFileSystemMigrator fileSystemMigrator)
        {
            Guard.AgainstNullArgument("config", config);
            Guard.AgainstNullArgument("scriptArgs", scriptArgs);
            Guard.AgainstNullArgument("console", console);
            Guard.AgainstNullArgument("fileSystem", fileSystem);
            Guard.AgainstNullArgument("logProvider", logProvider);
            Guard.AgainstNullArgument("fileSystemMigrator", fileSystemMigrator);

            _config = config;
            _scriptArgs = scriptArgs;
            _console = console;
            _fileSystem = fileSystem;
            _logger = logProvider.ForCurrentType();
            _fileSystemMigrator = fileSystemMigrator;

            _executeScriptCommand = new CrossAppDomainExecuteScriptCommand
            {
                Config = _config,
                ScriptArgs = _scriptArgs,
            };
        }

        public RoslynScriptInMemoryEngine(IScriptHostFactory scriptHostFactory, ILogProvider logProvider)
            : base(scriptHostFactory, logProvider)
        {
            Guard.AgainstNullArgument("logProvider", logProvider);

            _log = logProvider.ForCurrentType();
        }

        //private readonly ILog _log;

        public StoreController(IGenreRepository genres, IAlbumsRepository albums, ILogProvider log)
        {
            _genres = genres;
            _albums = albums;
            _log = log;
            //_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        }

        public AppDomainAssemblyResolver(
            ILogProvider logProvider,
            IFileSystem fileSystem,
            IAssemblyResolver resolver,
            IAssemblyUtility assemblyUtility,
            IDictionary<string, AssemblyInfo> assemblyInfoMap = null,
            Func<object, ResolveEventArgs, Assembly> resolveHandler = null)
        {
            Guard.AgainstNullArgument("logProvider", logProvider);
            Guard.AgainstNullArgument("fileSystem", fileSystem);
            Guard.AgainstNullArgument("resolver", resolver);
            Guard.AgainstNullArgument("assemblyUtility", assemblyUtility);

            _assemblyInfoMap = assemblyInfoMap ?? new Dictionary<string, AssemblyInfo>();
            _assemblyUtility = assemblyUtility;
            _logger = logProvider.ForCurrentType();
            _fileSystem = fileSystem;
            _resolver = resolver;

            if (resolveHandler == null)
            {
                resolveHandler = AssemblyResolve;
            }

            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(resolveHandler);
        }

        public AuthenticationService(
            ILogProvider logProvider,
            Lazy<IAuthorizationManager> authorizationManager,
            Lazy<IQueryableRepository<IPasswordStrength>> passwordStrengthRules,
            Lazy<IQueryableRepository<IPasswordAttemptsLimit>> passwordAttemptsLimitRepository,
            Lazy<ISqlExecuter> sqlExecuter,
            Lazy<IEnumerable<ISendPasswordResetToken>> sendPasswordResetTokenPlugins)
        {
            _logger = logProvider.GetLogger("AspNetFormsAuth.AuthenticationService");
            _authorizationManager = authorizationManager;
            _sqlExecuter = sqlExecuter;
            _sendPasswordResetTokenPlugin = new Lazy<ISendPasswordResetToken>(() => SinglePlugin(sendPasswordResetTokenPlugins));

            _passwordStrengthRules = passwordStrengthRules;
            _passwordAttemptsLimits = new Lazy<IList<PasswordAttemptsLimit>>(
                () =>
                {
                    var limits = passwordAttemptsLimitRepository.Value.Query()
                        .Select(l => new PasswordAttemptsLimit { MaxInvalidPasswordAttempts = l.MaxInvalidPasswordAttempts, TimeoutInSeconds = l.TimeoutInSeconds })
                        .ToList();
                    foreach (var limit in limits)
                        if (limit.TimeoutInSeconds == null || limit.TimeoutInSeconds <= 0)
                            limit.TimeoutInSeconds = int.MaxValue;
                    return limits;
                });
        }

 public MsSqlExecuter(ConnectionString connectionString, ILogProvider logProvider, IUserInfo userInfo)
 {
     _connectionString = connectionString;
     _userInfo = userInfo;
     _logger = logProvider.GetLogger("MsSqlExecuter");
     _performanceLogger = logProvider.GetLogger("Performance");
 }

 public ConceptApplicationRepository(
     ISqlExecuter sqlExecuter,
     ILogProvider logProvider)
 {
     _sqlExecuter = sqlExecuter;
     _logger = logProvider.GetLogger("ConceptApplicationRepository");
 }

        public HealthNancyModule(ILogProvider log, IApplicationHealthChecker checker) : base("/health")
        {
            // Make a module secure by using the below functions
            //this.RequiresHttps();
            //this.RequiresAuthentication();
            //this.RequireClaimOnUrl();  // To authorized make sure "^GET:http(s)?:\/\/.*\/health(\/)?$" is a claim.

            this.log = log;
            this.healthChecker = checker;

            Get["/"] = parameters =>
            {
                using (log.PushContextInfo("healthcheck"))
                {
                    bool isHealthy = false;
                    try
                    {
                        isHealthy = this.healthChecker.IsHealthy();
                    }
                    catch (Exception e)
                    {
                        isHealthy = false;
                        log.WithLogLevel(LogLevel.Error).WriteGeneralException(e);
                    }

                    HttpStatusCode statusCode = isHealthy ? HttpStatusCode.OK : HttpStatusCode.ServiceUnavailable;

                    return Response.AsText(statusCode.ToString())
                                   .WithStatusCode(statusCode)
                                   .WithContentType("text/plain")
                                   .WithHeader("Content-Disposition", "inline")
                                   .WithHeader("Cache-Control", "no-cache");
                }
            };
        }

 public LogActionAttribute()
 {
     if (Log == null)
     {
         Log = Container.Get<ILogProvider>();
     }
 }

 public WatchedDirectory(IEntityProvider entityLocator, ILogProvider logProvider, IDirectoryScanner directoryScanner)
 {
     _entityLocator = entityLocator;
     _log = logProvider.GetLogger(GetType());
     _acceptableExtensions = new List<string>();
     _directoryScanner = directoryScanner;
 }