C# ILoggerFacade类代码示例

        public PlaylistProvider(
            ISession session, 
            Dispatcher dispatcher,
            ILoggerFacade logger)
        {
            _session = session;
            _dispatcher = dispatcher;
            _logger = logger;
            _playlists = new ObservableCollection<Playlist>();

            if (_session.PlaylistContainer != null)
            {
                InitializePlaylistContainer();
            }
            else
            {
                _session.LoginComplete += (s, e) =>
                                              {
                                                  if (e.Status == Error.OK)
                                                  {
                                                      InitializePlaylistContainer();
                                                  }
                                              };
            }
        }

        public TransferViewModel(
            ILoggerFacade logger,
            IStatusBar statusBar,
            IRegionManager regionManager,
            IEventAggregator eventAggregator,
            ITradingServiceAsync tradingService,
            Bullsfirst.InterfaceOut.Oms.MarketDataServiceReference.IMarketDataServiceAsync marketDataService,
            UserContext userContext,
            ReferenceData referenceData)
        {
            logger.Log("TransferViewModel.TransferViewModel()", Category.Debug, Priority.Low);
            _logger = logger;
            _statusBar = statusBar;
            _regionManager = regionManager;
            _eventAggregator = eventAggregator;
            _tradingService = tradingService;
            _marketDataService = marketDataService;
            this.UserContext = userContext;
            this.ReferenceData = referenceData;

            _tradingService.TransferCashCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback);
            _tradingService.TransferSecuritiesCompleted += new EventHandler<AsyncCompletedEventArgs>(TransferCallback);
            _tradingService.AddExternalAccountCompleted += new EventHandler<AddExternalAccountCompletedEventArgs>(AddExternalAccountCallback);
            _marketDataService.GetMarketPriceCompleted +=
                new EventHandler<InterfaceOut.Oms.MarketDataServiceReference.GetMarketPriceCompletedEventArgs>(GetMarketPriceCallback);
            TransferCommand = new DelegateCommand<object>(this.TransferExecute, this.CanTransferExecute);
            AddExternalAccountCommand = new DelegateCommand<object>(this.AddExternalAccountExecute);
            this.PropertyChanged += this.OnPropertyChanged;
            this.ValidateAll();

            SubscribeToEvents();
        }

        public AccountsViewModel(
            ILoggerFacade logger,
            IStatusBar statusBar,
            IRegionManager regionManager,
            IEventAggregator eventAggregator,
            ITradingServiceAsync tradingService,
            UserContext userContext)
        {
            logger.Log("AccountsViewModel.AccountsViewModel()", Category.Debug, Priority.Low);
            _logger = logger;
            _statusBar = statusBar;
            _regionManager = regionManager;
            _eventAggregator = eventAggregator;
            _tradingService = tradingService;
            this.UserContext = userContext;

            _tradingService.OpenNewAccountCompleted += new EventHandler<OpenNewAccountCompletedEventArgs>(OpenNewAccountCallback);
            _tradingService.ChangeAccountNameCompleted += new EventHandler<AsyncCompletedEventArgs>(ChangeAccountNameCallback);
            CreateAccountCommand = new DelegateCommand<object>(this.CreateAccountExecute);
            EditAccountCommand = new DelegateCommand<object>(this.EditAccountExecute);
            UpdateAccountsCommand = new DelegateCommand<object>(this.UpdateAccountsExecute);
            SelectAccountCommand = new DelegateCommand<object>(this.SelectAccountExecute);

            SubscribeToEvents();
        }

 public LocationInputViewModel(CompositionContainer container, ILoggerFacade loggerFacade, IEventAggregator eventAggregator)
 {
     this.Street = string.Empty;
     this.Number = string.Empty;
     this.City = string.Empty;
     this.PostCode = string.Empty;
     this.OkCommand = new DelegateCommand<object>(
     this.OnOKClicked, this.CanOKClicked);
     this.CancelCommand = new DelegateCommand<object>(
     this.OnCancelClicked, this.CanCancelClicked);
     this.MoveDownStopCommand = new DelegateCommand<object>(
     this.OnMoveDownCommand, this.CanMoveDownCommand);
     this.MoveUpStopCommand = new DelegateCommand<object>(
     this.OnMoveUpCommand, this.CanMoveUpCommand);
     this.DeleteStopCommand = new DelegateCommand<object>(
     this.OnDeleteStopCommand, this.CanDeleteStopCommand);
     this._container = container;
     this._loggerFacade = loggerFacade;
     this.eventAggregator = eventAggregator;
     mainTabEvent = eventAggregator.GetEvent<CompositePresentationEvent<MainTabInfo>>();
     _notificationErrorInteraction = new InteractionRequest<Notification>();
     this.LocationSelectedCommand = new DelegateCommand<object>(
     this.OnLocationSelected, this.CanLocationSelected);
     this.StopSelectedCommand = new DelegateCommand<object>(
     this.OnStopSelected, this.CanStopSelected);
     this.LocationsSelected = new ObservableCollection<GeoLocatorDetail>();
     this.LocationResults = new ObservableCollection<GeoLocatorDetail>();
     this.RouteDirections = new ObservableCollection<string>();
     this.SelectionVisibility = Visibility.Visible;
     this.StopsVisibility = Visibility.Collapsed;
     this.RouteDirectionsVisibility = Visibility.Collapsed;
 }

 public DataRepositoryObjectViewModel( IDataRepository dataRepository, IRegionManager regionManager, IInteractionService interactionService, ILoggerFacade logger )
     : base(regionManager, interactionService, logger)
 {
     Model = null;
      InTransaction = false;
      this.DataRepository = dataRepository;
 }

 public static ILoggerFacade InitLog4Net(string logName)
 {
     if (m_logger == null) {
         m_logger = new Log4NetLogger(logName);
     }
     return m_logger;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="RosterViewModel"/> class.
        /// </summary>
        /// <param name="eventAggregator">The event aggregator.</param>
        /// <param name="logger">The logger.</param>
        /// <param name="rosterService">The roster service.</param>
        public RosterViewModel(IEventAggregator eventAggregator, ILoggerFacade logger, RosterService rosterService)
        {
            this.RosterService = rosterService;
            this.RegisterHandlers();

            logger.Log("RosterViewModel Initialized", Category.Debug, Priority.None);
        }

 public ClientsViewModel(IEventAggregator aggregator, IRegionManager regionManager,
     IConnectionManager connectionManager, IInteractionService interactionService, ILoggerFacade loggerFacade) :
         base(aggregator, regionManager, connectionManager, interactionService, loggerFacade)
 {
     //aggregator.GetEvent<BootstrappingCompleteUiEvent>().Subscribe(BootstrappCompletedHandler);
     AdditionalRoomsValues = new ObservableCollection<string> {"Yes", "No"};
 }

 public ReservationModule(IUnityContainer container, IRegionManager regionManager, IEventAggregator eventAggregator, ILoggerFacade logger)
 {
     this._container = container;
     this._regionManager = regionManager;
     this._eventAggregator = eventAggregator;
     this._logger = logger;
 }

        public OrdersViewModel(
            ILoggerFacade logger,
            IStatusBar statusBar,
            IEventAggregator eventAggregator,
            ITradingServiceAsync tradingService,
            UserContext userContext,
            ReferenceData referenceData)
        {
            logger.Log("PositionsViewModel.PositionsViewModel()", Category.Debug, Priority.Low);
            _logger = logger;
            _statusBar = statusBar;
            _eventAggregator = eventAggregator;
            _tradingService = tradingService;
            this.UserContext = userContext;
            this.Orders = new ObservableCollection<Order>();
            this.ReferenceData = referenceData;

            this.UpdateOrdersCommand = new DelegateCommand<object>(this.UpdateOrdersExecute);
            this.ResetFilterCommand = new DelegateCommand<object>(this.ResetFilterExecute);
            this.CancelOrderCommand = new DelegateCommand<object>(this.CancelOrderExecute);

            _tradingService.GetOrdersCompleted +=
                new EventHandler<GetOrdersCompletedEventArgs>(GetOrdersCallback);
            _tradingService.CancelOrderCompleted +=
                new EventHandler<AsyncCompletedEventArgs>(CancelOrderCallback);
            this.UserContext.PropertyChanged +=
                new PropertyChangedEventHandler(OnUserContextPropertyChanged);

            ResetFilter();
            SubscribeToEvents();
        }

 public MefModuleManager(
     IModuleInitializer moduleInitializer,
     IModuleCatalog moduleCatalog,
     ILoggerFacade loggerFacade)
     : base(moduleInitializer, moduleCatalog, loggerFacade)
 {
 }

 /// <summary>
 ///     Initializes a new instance of the <see cref="VMBase" /> class.
 /// </summary>
 /// <param name="aggregator">The aggregator.</param>
 /// <param name="regionManager">The region manager.</param>
 /// <param name="connectionManager"></param>
 /// <param name="interactionService"></param>
 /// <param name="loggerFacade"></param>
 /// <exception cref="System.ArgumentNullException">
 ///     Any parameter
 /// </exception>
 public ApplicationMenuViewModel(IEventAggregator aggregator, IRegionManager regionManager,
     IConnectionManager connectionManager,
     IInteractionService interactionService, ILoggerFacade loggerFacade)
     : base(aggregator, regionManager, connectionManager, interactionService, loggerFacade)
 {
     EventAggregator.GetEvent<UserAuthCompletedEvent>().Subscribe(OnUserAuth);
 }

 public BaseIOViewModel(SelectedSettings settings, string portName, ILoggerFacade logger)
 {
     this.logger = logger;
     this.settings = settings;
     this.portName = portName;
     StopCommand = new DelegateCommand(OnStop);
 }

 public CustomerListViewModel(IUnityContainer container)
 {
   this.container = container;
   this.logger = this.container.Resolve<ILoggerFacade>();
   this.eventAggregator = this.container.Resolve<IEventAggregator>();
   this.modelService = this.container.Resolve<IModelService>();
 }

        protected PrismUnityApplication(ILoggerFacade logger, IUnityContainer container) : base(logger)
        {
            if (container == null)
                throw new InvalidOperationException("Unity container is null");

            Container = container;
        }