C# ILoggingService类代码示例

        public SessionViewModel(IEventAggregator eventAggregator, IWindowManager windowManager, ILoggingService loggingService)
        {
            EventAggregator = eventAggregator;
            //EventAggregator.Publish(new NavigationEvent { PageNavigatedTo = "SessionView" });
            _windowManager = windowManager;
            _loggingService = loggingService;
            MessageBox = new StandardMessageBox();
            if (!DesignerProperties.IsInDesignTool)
            {
                LoadOperation lo = context.Load(context.GetSponsorswithAllPropertiesQuery(App.Event.Id));
                lo.Completed += delegate
                {
                    TrackList = context.Tracks;
                    if (lo.HasError)
                    {
                        ErrorWindow.CreateNew(lo.Error.Message);
                        _loggingService.LogException(lo.Error);
                    }
                };
            }
            else
            {

            }
        }

 public AccountService(ILoggingService loggingService, IAccountRepository accountRepository,
     ISharedHelper helper)
 {
     _loggingService = loggingService;
     _accountRepository = accountRepository;
     _helper = helper;
 }

 public ScreenshotCefClient(ScreenshotCore core, int width, int height, ILoggingService loggingService)
 {
     this.lifeSpanHandler = new WebLifeSpanHandler(core);
     this.loadHandler = new WebLoadHandler(core);
     this.renderHandler = new ScreenshotRenderHandler(core, width, height);
     this.loggingService = loggingService;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SitemapService"/> class.
 /// </summary>
 /// <param name="loggingService">The logging service.</param>
 /// <param name="urlHelper">The URL helper.</param>
 public SitemapService(
     ILoggingService loggingService,
     UrlHelper urlHelper)
 {
     this.loggingService = loggingService;
     this.urlHelper = urlHelper;
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="membershipRepository"> </param>
 /// <param name="settingsRepository"> </param>
 /// <param name="emailService"> </param>
 /// <param name="localizationService"> </param>
 /// <param name="activityService"> </param>
 /// <param name="privateMessageService"> </param>
 /// <param name="membershipUserPointsService"> </param>
 /// <param name="topicNotificationService"> </param>
 /// <param name="voteService"> </param>
 /// <param name="badgeService"> </param>
 /// <param name="categoryNotificationService"> </param>
 /// <param name="loggingService"></param>
 /// <param name="uploadedFileService"></param>
 /// <param name="postRepository"></param>
 /// <param name="pollVoteRepository"></param>
 /// <param name="pollAnswerRepository"></param>
 /// <param name="pollRepository"></param>
 /// <param name="topicRepository"></param>
 /// <param name="favouriteRepository"></param>
 /// <param name="categoryService"></param>
 public MembershipService(IMembershipRepository membershipRepository, ISettingsRepository settingsRepository,
     IEmailService emailService, ILocalizationService localizationService, IActivityService activityService,
     IPrivateMessageService privateMessageService, IMembershipUserPointsService membershipUserPointsService,
     ITopicNotificationService topicNotificationService, IVoteService voteService, IBadgeService badgeService,
     ICategoryNotificationService categoryNotificationService, ILoggingService loggingService, IUploadedFileService uploadedFileService,
     IPostRepository postRepository, IPollVoteRepository pollVoteRepository, IPollAnswerRepository pollAnswerRepository,
     IPollRepository pollRepository, ITopicRepository topicRepository, IFavouriteRepository favouriteRepository,
     ICategoryService categoryService)
 {
     _membershipRepository = membershipRepository;
     _settingsRepository = settingsRepository;
     _emailService = emailService;
     _localizationService = localizationService;
     _activityService = activityService;
     _privateMessageService = privateMessageService;
     _membershipUserPointsService = membershipUserPointsService;
     _topicNotificationService = topicNotificationService;
     _voteService = voteService;
     _badgeService = badgeService;
     _categoryNotificationService = categoryNotificationService;
     _loggingService = loggingService;
     _uploadedFileService = uploadedFileService;
     _postRepository = postRepository;
     _pollVoteRepository = pollVoteRepository;
     _pollAnswerRepository = pollAnswerRepository;
     _pollRepository = pollRepository;
     _topicRepository = topicRepository;
     _favouriteRepository = favouriteRepository;
     _categoryService = categoryService;
 }

 public ToolsController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IUserService userService,
     ISettingsService settingsService,
     ILocalizationService localizationService,
     IRoleService roleService)
     : base(loggingService, unitOfWorkManager, userService, settingsService, localizationService)
 {
 }

 internal AssemblyResourceStore(Type evidence)
 {
     this.evidence = evidence;
     logger = Initializer.Instance.WindsorContainer.Resolve<ILoggingService>();
     _isoFile = IsolatedStorageFile.GetMachineStoreForAssembly();
     _backingFile = new IsolatedStorageFileStream(evidence.Assembly.GetName().Name, FileMode.OpenOrCreate, _isoFile);
     if (_backingFile.Length > 0)
     {
         try
         {
             var formatter = new BinaryFormatter();
             store = (Dictionary<string, object>)formatter.Deserialize(_backingFile);
         }
         catch (Exception ex)
         {
             logger.Log(Common.LogLevel.Error, string.Format("Error deserializing resource store for {0}. Resetting resource store.", evidence.Assembly.GetName().Name));
             logger.Log(Common.LogLevel.Debug, string.Format("Deserialize error: {0}", ex.Message));
             store = new Dictionary<string, object>();
         }
     }
     else
     {
         store = new Dictionary<string, object>();
     }
 }

        protected override void OnInitialized(EventArgs e)
        {
            base.OnInitialized(e);
            //this.Style = this.TryFindResource(typeof(TextBox)) as Style;
            this.loggingService = (ILoggingService)this.serviceProvider.GetService(typeof(ILoggingService));

            if (this.loggingService == null)
            {
                this.Text = "ERROR:  Unable to get logging service; no output available.";
            }
            else
            {
                // Every output view gets its own text (and starts with what has accumulated so far, so they're all equal).
                this.Text = this.loggingService.AccumulatedLog;
                if (this.IsLoaded)
                {
                    OnLoaded(this, null);
                }
                else
                {
                    this.Loaded += OnLoaded;
                }

                this.loggingService.MessageLogged += OnMessageLogged;
            }
        }

 public FileController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, 
     ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService, IUploadedFileService uploadedFileService, ICategoryService categoryService, ICacheService cacheService)
     : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService, cacheService)
 {
     _uploadedFileService = uploadedFileService;
     _categoryService = categoryService;
 }

 public CombinerResponseStream(
     Stream responseStream,
     bool combineJs,
     bool combineCss,
     bool minifyJs,
     bool minifyCss,
     bool versionOnly,
     bool prependCdnHostToImages,
     string jsVersion,
     string cssVersion,
     string sharedVersion,
     int ieVersion,
     string requestedUrl,
     ICombinerService combinerService,
     ILoggingService loggingService,
     string combinedResourcesUrl,
     string cdnHostToPrepend)
     : base(responseStream)
 {
     _combineJs = combineJs;
     _combineCss = combineCss;
     _minifyJs = minifyJs;
     _minifyCss = minifyCss;
     _versionOnly = versionOnly;
     _jsVersion = jsVersion;
     _cssVersion = cssVersion;
     _sharedVersion = sharedVersion;
     _ieVersion = ieVersion;
     _requestedUrl = requestedUrl;
     _combinerService = combinerService;
     _logger = loggingService;
     _combinedResourcesUrl = combinedResourcesUrl;
     _prependCdnHostToImages = prependCdnHostToImages;
     _cdnHostToPrepend = cdnHostToPrepend;
 }

 public JustGivingService(IHttpClient httpClient, ILoggingService loggingService, string apiKey, string endPoint, int charityId)
 {
     _httpClient = httpClient;
     _loggingService = loggingService;
     _endPoint = string.Format("{0}{1}/v1/", endPoint, apiKey);
     _charityId = charityId;
 }

        public ProductService(
                            IProductRepository productRepository,
                            ICacheStorage cacheStorage,
                            IConfigurationRepository configurationRepository,
                            ILoggingService loggingService)
        {
            if (productRepository == null)
            {
                throw new ArgumentNullException("ProductRepository");
            }

            if (cacheStorage == null)
            {
                throw new ArgumentNullException("CacheStorage");
            }

            if (configurationRepository == null)
            {
                throw new ArgumentException("Configuration");
            }

            if (loggingService == null)
            {
                throw new ArgumentException("Logging");
            }

            this._productRepository = productRepository;
            this._cacheStorage = cacheStorage;
            this._configurationRepository = configurationRepository;
            this._loggingService = loggingService;
        }

        public AzureTentQueues(IGeneralConfiguration configuration, 
            IJsonHelpers jsonHelpers,
            ITaskHelpers taskHelpers,
            ILoggingService loggingService)
        {
            Ensure.Argument.IsNotNull(configuration, nameof(configuration));
            Ensure.Argument.IsNotNull(jsonHelpers, nameof(jsonHelpers));
            Ensure.Argument.IsNotNull(taskHelpers, nameof(taskHelpers));
            Ensure.Argument.IsNotNull(loggingService, nameof(loggingService));

            this.taskHelpers = taskHelpers;
            this.loggingService = loggingService;

            // Create the storage account from the connection string, and the corresponding client.
            var queuesStorageAccount = CloudStorageAccount.Parse(configuration.AzureQueuesConnectionString);
            var queuesClient = queuesStorageAccount.CreateCloudQueueClient();

            // Create the queues references.
            this.mentionsQueue = queuesClient.GetQueueReference("mentions");
            this.subscriptionsQueue = queuesClient.GetQueueReference("subscriptions");
            this.appNotificationQueue = queuesClient.GetQueueReference("appnotifications");
            this.metaSubscriptionQueue = queuesClient.GetQueueReference("metasubscriptions");
            this.retryQueue = queuesClient.GetQueueReference("retries");

            // Create the IQueue objects.
            this.Mentions = new AzureQueue<QueueMentionMessage>(this.mentionsQueue, jsonHelpers);
            this.Subscriptions = new AzureQueue<QueueSubscriptionMessage>(this.subscriptionsQueue, jsonHelpers);
            this.AppNotifications = new AzureQueue<QueueAppNotificationMessage>(this.appNotificationQueue, jsonHelpers);
            this.MetaSubscriptions = new AzureQueue<QueueMetaSubscriptionMessage>(this.metaSubscriptionQueue, jsonHelpers);
            this.Retries = new AzureQueue<QueueRetryMessage>(this.retryQueue, jsonHelpers);

            // Create the initializer for this component.
            this.initializer = new TaskRunner(this.InitializeOnceAsync);
        }

 public SnippetsController(ILoggingService loggingService, IUnitOfWorkManager unitOfWorkManager, IMembershipService membershipService, 
     ILocalizationService localizationService, IRoleService roleService, ISettingsService settingsService,
     IMembershipUserPointsService membershipUserPointsService, ICacheService cacheService)
     : base(loggingService, unitOfWorkManager, membershipService, localizationService, roleService, settingsService, cacheService)
 {
     _membershipUserPointsService = membershipUserPointsService;
 }

 public SystemNetEmailService(IConfigurationRepository configurationRepository, ILoggingService loggingService)
 {
     if (configurationRepository == null) throw new ArgumentNullException("ConfigurationRepository");
     if (loggingService == null) throw new ArgumentNullException("LoggingService");
     _configurationRepository = configurationRepository;
     _loggingService = loggingService;
 }