C# Logger.Write方法代码示例

        static void LoadTasks(Logger logger, XmlDocument taskFile)
        {
            Tasks = new List<Task>();

            foreach (XmlNode node in taskFile.DocumentElement.ChildNodes)
            {
                if (Plugins.ContainsKey(node.Attributes["type"].Value))
                {
                    Type pluginType = Plugins[node.Attributes["type"].Value];
                    object[] args = new object[] { logger, node };
                    try
                    {
                        Task task = (Task)Activator.CreateInstance(pluginType, args);
                        Tasks.Add(task);
                    }
                    catch (Exception)
                    {
                        if (node.Attributes["name"] == null)
                            logger.Write(String.Format("Error creating unnamed task of type {0} (try checking the attributes in your taskfile!)", pluginType.Name), Priority.Error);
                        else
                            logger.Write(String.Format("Error creating '{1}' of type {0} (try checking the attributes in your taskfile!)", pluginType.Name, node.Attributes["name"].Value), Priority.Error);
                    }
                }
                else
                    logger.Write("Unable to find '" + node.Attributes["type"].Value + "' plugin", Priority.Error);
            }
        }

        public void Initialize(Logger log, string password)
        {
            // get log instance to disk
            _log = log;

            // if stream are empty, create header page and save to stream
            if (_stream.Length == 0)
            {
                _log.Write(Logger.DISK, "initialize new datafile");

                // create a new header page in bytes
                var header = new HeaderPage();

                if(password != null)
                {
                    _log.Write(Logger.DISK, "datafile encrypted");

                    header.Password = AesEncryption.HashSHA1(password);
                    header.Salt = AesEncryption.Salt();
                }

                // write bytes on page
                this.WritePage(0, header.WritePage());
            }
        }

        static void Main(string[] args)
        {
            var logger = new Logger("Main");
            var JSON_FILENAME = "configuration.json";

            try
            {

                var config = new Json.Deserializer().parseFromFile<GoogleOAuth2Config>(JSON_FILENAME);
                logger.Write(0, config.ToString());

                var token = new GoogleService.Authenticator().getAuthenticationToken(config);

                logger.Write(0, token);

                 string metrics = "ga:totalEvents";
                string dimensions =
                "ga:date,ga:hostname,ga:pageTitle,ga:dimension1,ga:eventAction,ga:eventCategory,ga:eventLabel";

                GoogleService.Fetch.getQueryAnalyticsResult(token, metrics, dimensions);

            }
            catch (Exception exc)
            {
                logger.Write((MessageType)4, exc.Message);

            }
        }

		public void TestSources()
		{
			var logger = new Logger("logs");
			AppDomain.CurrentDomain.SetData("DataDirectory", Path.GetFullPath(@"..\App_Data\"));

			var parallelOptions = new ParallelOptions // if server, sandboxerRunner and test run in one machine
			{
				MaxDegreeOfParallelism = Environment.ProcessorCount
			};

			var res = Parallel.ForEach(GetSources(), parallelOptions, async source =>
			{
				var id = String.Format("{0:D10}", source.Id);
				var executionService = new CsSandboxExecutionService();
				SubmissionResult runResult = null;
				try
				{
					runResult = await executionService.Submit(source.Code, id);
				}
				catch (Exception ex)
				{
					logger.Write(source, ex);
				}
				if (runResult != null && !IsCorrectSolution(source, runResult))
					logger.Write(source, runResult);
			});

			while (!res.IsCompleted)
			{
				Thread.Sleep(60*1000);
			}
		}

        public string getAuthenticationToken(GoogleOAuth2Config config)
        {
            var logger = new Logger("GoogleService.Authenticator");
            var registry = new Windows.Registry.Helper(config.ApiAccessKey);

            var expiryTime = registry.getExpireTime();
            if (String.IsNullOrEmpty(expiryTime) || expiryTime.Length < 4)
            {
                expiryTime = FALLBACK_EXPIRY_DATE;
            }
            var ExpireDateTime = Convert.ToDateTime(expiryTime);
            var ExpireTimeNow = DateTime.UtcNow;
            TimeSpan span = ExpireDateTime - ExpireTimeNow;
            double iExpireLeft = span.TotalSeconds;

            logger.Write(0, "Expire time left (sec): " + iExpireLeft);

            if (iExpireLeft < 60) {
                logger.Write(0, "Requesting authentication token from server...");
                var tokenObject = requestAuthenticationToken(config);

                if (tokenObject.access_token == null)
                    throw new NullReferenceException("access_token is null");

                registry.putValue(Helper.SubKey.TokenName, tokenObject.access_token);
                registry.putInterval(Helper.SubKey.ExpireTime, tokenObject.expires_in);
                logger.Write(0, "Token Received successfully");
            }

            string accessToken = registry.getAccessToken();
            return accessToken;
        }

        public ChatServer(string identifier, Config config)
        {
            Identifier = identifier;
            Context = new ChatServerContext(config);
            Endpoints = new Dictionary<string, ServerProtocol>();
            Log = new Logger($"Chat Server ({Identifier})");
            Log.Write(LogSeverity.Info, "Created chat server container.");

            string[] channels = Context.Config.Get("Chat.Context", "Channels", "Lounge").Split(' ');

            for (int i = 0; i < channels.Length; i++) {
                string configSection = $"Chat.Channel.{channels[i]}";

                Channel channel = new Channel {
                    Id = i + 1,
                    Name = "#" + (Context.Config.ContainsKey(configSection, "Name") ? Context.Config.Get<string>(configSection, "Name") : channels[i]).ToLower(),
                    Topic = Context.Config.ContainsKey(configSection, "Topic") ? Context.Config.Get<string>(configSection, "Topic") : "This channel has no topic.",
                    Created = DateTime.UtcNow
                };

                if (Context.Config.ContainsKey(configSection, "Password")) {
                    channel.SetPassword(Context.Config.Get<string>(configSection, "Password"));
                }

                if (Context.Config.ContainsKey(configSection, "MinimumHierarchy")) {
                    channel.MinimumHierarchy = Context.Config.Get<int>(configSection, "MinimumHierarchy");
                }

                Context.Channels.Add(channel);
                Log.Write(LogSeverity.Info, $"Created {channel.Name}.");
            }
        }

        static void LoadPlugins(Logger logger)
        {
            Plugins = new Dictionary<string, Type>();

            DirectoryInfo pluginDirectory = new DirectoryInfo(Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "plugins"));
            foreach (FileInfo file in pluginDirectory.GetFiles("*.dll"))
            {
                logger.Write(String.Format("Searching {0} for plugins", file.Name), Priority.Debug);
                Assembly assembly = Assembly.LoadFile(file.FullName);
                foreach (Type type in assembly.GetTypes())
                {
                    object[] attributes = type.GetCustomAttributes(typeof(TaskAttribute), true);
                    if (type.IsSubclassOf(typeof(Task)) && attributes != null)
                    {
                        foreach (object attribute in attributes)
                        {
                            if (attribute is TaskAttribute)
                            {
                                logger.Write(String.Format("Loading plugin {0}", type.FullName), Priority.Debug);
                                TaskAttribute taskAttribute = (TaskAttribute)attributes[0];
                                Plugins[taskAttribute.TypeName] = type;
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Default constructor.
        /// </summary>
        public SurfaceWindow1()
        {
            log = new Logger("Rememo");
            log.Write("Starting application");
            
            if (DiaryManager.ConfigExists())
            {
                InitializeComponent();

                clock.Elapsed += new System.Timers.ElapsedEventHandler(clock_Elapsed);
                log.Write("Config found!");
                clock.Enabled = true;
                log.Write("Clock enabled");
                log.Write("Welcome Text set");
            }
            else
            {  
                
                InitializeComponent();

                clock.Elapsed += new System.Timers.ElapsedEventHandler(clock_Elapsed);
                log.Write("No config file!");
                clock.Enabled = true;
                log.Write("clock enabled");
                welcomeText(false);
                
                
            }
            // Add handlers for Application activation events
            AddActivationHandlers();

        }

 public void Should_support_using_for_Indent()
 {
     var output = new StringWriter();
     var logger = new Logger(output);
     logger.Write("1");
     using(logger.Indent())
         logger.Write("2");
     logger.Write("3");
     Assert.AreEqual(string.Format("1{0}\t2{0}3{0}", output.NewLine), output.ToString());
 }

        static void Main(string[] args)
        {
            ILogger log = new Logger();
            log.Write("Hello World.");

            Console.ReadKey();
        }

 public void Write_should_support_formatting()
 {
     var output = new StringWriter();
     var logger = new Logger(output);
     logger.Write("{0}+{1}", 1, 2);
     Assert.AreEqual("1+2" + output.NewLine, output.ToString());
 }

    private void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
    {
      var error = e.ExceptionObject as Exception;
      if (error == null)
        return;

      var logger = new Logger(AppDomain.CurrentDomain.BaseDirectory + "/UnhandledError.log");
      logger.Write(error);
    }

        public void Test_WriteLine_Calls_Write_With_Setup_Method()
        {
            // Arrange
            var stub = new StubILogWriter();
            var mock = stub.AsMock();
            mock.Setup(lw => lw.Write(It.IsAny<string>()));
            mock.Setup(lw => lw.Write(It.IsAny<int>()));

            var logger = new Logger(mock.Object);

            // Act
            logger.Write("Hello, logger!");
            logger.Write(42);

            // Assert
            // We're not explicitly stated what we're expecting.
            // mock.Setup expectations would be use.
            mock.Verify();
        }

        /// <summary>
        /// Environment startup.
        /// </summary>
        /// <param name="dataPath">Path used for data storage, leave null to just throw it in the same directory as the executables.</param>
        public static void Prepare(string dataPath = null)
        {
            Root = dataPath != null ? dataPath : AppDomain.CurrentDomain.BaseDirectory;

            if (!Directory.Exists(Root)) {
                DirectoryInfo dirInfo = Directory.CreateDirectory(dataPath);
                dirInfo.Attributes = FileAttributes.Directory | FileAttributes.Hidden;
            }

            Log = new Logger("Railgun");
            Log.Write(LogSeverity.Info, "Environment prepared.");
            Config = new Config("Railgun");
        }

        public Server(string identifier, ChatServerContext context)
            : base(identifier, context)
        {
            if (Hostname == null) {
                Hostname = Context.Config.Get("Chat.Protocols.IRC", "Hostname", "irc.flash.moe");
            }

            Log = new Logger($"IRC Server ({Identifier})");

            short bindPort = Context.Config.Get<short>("Chat.Protocols.IRC", "Port", 6667);
            Listener = new TcpListener(IPAddress.Any, bindPort);
            Log.Write(LogSeverity.Info, "Creating IRC server on port {0}.", bindPort.ToString());
        }