Exemple #1
0
 public CommentService(IUnitOfWorkFactory uowFactory, IRepositoryFactory repositoryFactory, ILogFactory logFactory)
 {
     _unitOfWorkFactory = uowFactory;
     _repositoryFactory = repositoryFactory;
     _commentBuilder    = new CommentBuilder();
     _logger            = logFactory.CreateLogger(GetType());
 }
        public ExternalDataService(IUnitOfWorkFactory unitOfWorkFactory, ILogFactory logFactory)
        {
            this.uow       = unitOfWorkFactory.Create(typeof(AppDbContext));
            userRepository = uow.CreateRepository <ExternalData>();

            logger = logFactory.CreateLogger <ExternalDataService>();
        }
 public CategoryService(IUnitOfWorkFactory uowFactory, IRepositoryFactory repositoryFactory, ILogFactory logFactory)
 {
     _unitOfWorkFactory = uowFactory;
     _repositoryFactory = repositoryFactory;
     _categoryBuilder   = new CategoryBuilder();
     _blogBuilder       = new BlogBuilder();
     _logger            = logFactory.CreateLogger(GetType());
 }
 public UserService(IBlogService blogService, IUnitOfWorkFactory uowFactory,
                    IRepositoryFactory repositoryFactory, ILogFactory logFactory)
 {
     _blogUserBuilder   = new BlogUserBuilder();
     _blogService       = blogService;
     _logger            = logFactory.CreateLogger(GetType());
     _repositoryFactory = repositoryFactory;
     _unitOfWorkFactory = uowFactory;
 }
Exemple #5
0
 /// <summary>
 /// Create a new logger.
 /// </summary>
 /// <param name="type">Type that requested a logger.</param>
 /// <returns>Logger for the specified type;</returns>
 public static ILogger CreateLogger(Type type)
 {
     if (_factory == null)
     {
         LogFilter lf = new LogFilter();
         lf.AddStandardRules();
         lf.AddType(type, LogLevel.Error);
         _factory = NullLogFactory.Instance;// (lf);
     }
     return(_factory.CreateLogger(type));
 }
Exemple #6
0
 public BlogService(ICategoryService categoryService, IPostService postService, IUnitOfWorkFactory uowFactory,
                    IRepositoryFactory repositoryFactory, ILogFactory logFactory)
 {
     _blogBuilder       = new BlogBuilder();
     _userBuilder       = new BlogUserBuilder();
     _categoryService   = categoryService;
     _postService       = postService;
     _unitOfWorkFactory = uowFactory;
     _repositoryFactory = repositoryFactory;
     _logger            = logFactory.CreateLogger(GetType());
 }
        private MessageMetaData[][] GetMessages(HtmlDocument[] htmlDocs)
        {
            var tasksList = new List <Task <MessageMetaData[]> >();
            var logger    = logFactory.CreateLogger(typeof(HtmlScraper));
            Task <MessageMetaData[]> task;

            foreach (var doc in htmlDocs)
            {
                task = GetMessagesAsync(doc, logger);
                tasksList.Add(task);
            }

            var result = Task.WhenAll(tasksList).Result;

            return(result);
        }
        /// <summary>
        /// Gets the log with the specified name.
        /// </summary>
        /// <param name="name">The name of the log.</param>
        /// <returns>The <see cref="ILog"/>  with the specified name.</returns>
        public static ILog GetLogger(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }

            ILog logger;

            if (!_loggers.TryGetValue(name, out logger))
            {
                logger = _factory.CreateLogger(name);
                _loggers.Add(name, logger);
            }

            return(logger);
        }
 public DomainMigratorService(ILogFactory logFactory, IContextFactory contextFactory)
 {
     _logger         = logFactory.CreateLogger("DomainMigrator");
     _contextFactory = contextFactory;
 }
 /// <summary>
 ///
 /// </summary>
 /// <param name="next"></param>
 /// <param name="logFactory">The logging service</param>
 public LoggingMiddleware(OwinMiddleware next, ILogFactory logFactory) : base(next)
 {
     logService = logFactory.CreateLogger <LoggingMiddleware>();
 }
 /// <summary>
 /// Create a new logger.
 /// </summary>
 /// <param name="type">Type that requested a logger.</param>
 /// <returns>Logger for the specified type;</returns>
 public static ILogger CreateLogger(Type type)
 {
     return(_factory.CreateLogger(type));
 }
Exemple #12
0
 protected MongoRepository(ILogFactory logFactory, IMongoContextFactory contextFactory, string loggerName)
 {
     Logger          = logFactory.CreateLogger(loggerName);
     _contextFactory = contextFactory;
 }
Exemple #13
0
 /// <summary>
 /// Get logger.
 /// </summary>
 /// <param name="loggerName">Logger name.</param>
 /// <returns>Logger.</returns>
 public static ILog GetLogger(string loggerName)
 {
     return(loggers.GetOrAdd(loggerName, name => logFactory.CreateLogger(name)));
 }
Exemple #14
0
 /// <summary>
 /// Create a new logger.
 /// </summary>
 /// <returns>Logger for the specified type;</returns>
 public static ILogger CreateLogger <T>()
 {
     return(_factory.CreateLogger(typeof(T)));
 }
Exemple #15
0
 protected Repository(ILogFactory logFactory, IContextFactory contextFactory, string loggerName)
     : this(logFactory.CreateLogger(loggerName), contextFactory)
 {
 }
 public HomeController(IExternalDataService externalDataService, ILogFactory logFactory)
 {
     this.externalDataService = externalDataService;
     logService = logFactory.CreateLogger <AccountController>();
 }
Exemple #17
0
 private QueueService(ILogFactory logFactory)
 {
     _logger = logFactory.CreateLogger("QueueService");
 }
Exemple #18
0
 private TableRepository(ILogFactory logFactory)
 {
     _logger = logFactory.CreateLogger("TableRepository");
 }
Exemple #19
0
 /// <summary>
 /// Create a new logger or get the default logger.
 /// </summary>
 /// <returns>Create a new logger or get the default logger.</returns>
 public static ILogger CreateLogger()
 {
     return(_factory.CreateLogger());
 }
Exemple #20
0
 public InstrumentedAuthorizationService(IAuthorizationService underlyingAuthService, ILogFactory logFactory)
 {
     _underlyingAuthService = underlyingAuthService;
     _logger = logFactory.CreateLogger();
 }
Exemple #21
0
 /// <summary>
 /// Initializes a new instance of the <see cref="HealthChecker" /> class.
 /// </summary>
 /// <param name="logFactory">The logger.</param>
 public HealthChecker(ILogFactory logFactory)
 {
     logger       = logFactory.CreateLogger <HealthChecker>();
     this.timeout = TimeSpan.FromSeconds(5);
 }
Exemple #22
0
 private BlobRepository(ILogFactory logFactory)
 {
     _logger = logFactory.CreateLogger("BlobRepository");
 }
 internal static ILog CreateLogger(Type type)
 {
     return(logFactory.CreateLogger(type));
 }