C# ILog.Warn方法代码示例

 public static void Warn(string message, Exception ex, ILog log)
 {
     if (log.IsWarnEnabled)
     {
         log.Warn(message, ex);
     }
 }

 public static void Warn(System.Type type, object message)
 {
     logger = LogManager.GetLogger(type);
     if (!logger.Logger.Repository.Configured)
         XmlConfigurator.ConfigureAndWatch(new System.IO.FileInfo(GetConfigFile() + ".config"));
     logger.Warn(message);
 }

 public static void LogRestWarn(ILog logger, IRestResponse restResponse, string warnHeading)
 {
     if (logger != null && restResponse != null)
     {
         var stringBuilder = BuildLoggingString(restResponse, warnHeading);
         logger.Warn(stringBuilder.ToString());
     }
 }

 internal static void LogMessages(ILog log)
 {
     log.Info("This is an info");
     log.InfoFormat("Base called at {0}", DateTime.Now);
     log.Debug("This is a debug");
     log.Warn("This is a warning");
     log.Error("This is an error");
 }

        public TrajectoryPlotter(string inputDirectory, string inputFilenamePattern, string outputDirectory, string outputFilename, int width, int height, uint bailout)
        {
            _inputDirectory = inputDirectory;
            _inputFilenamePattern = inputFilenamePattern;
            _outputDirectory = outputDirectory;
            _outputFilename = outputFilename;
            _resolution = new Size(width, height);
            _bailout = bailout;

            _log = LogManager.GetLogger(GetType());

            if (width % 4 != 0)
            {
                _log.Warn("The width should be evenly divisible by 4");
            }
            if (height % 4 != 0)
            {
                _log.Warn("The height should be evenly divisible by 4");
            }

            _hitPlot = new HitPlot4x4(_resolution);
        }

        public BeaglePlugin()
        {
            server = Daemon.Server;
            db = Daemon.DefaultDatabase;
            log = Daemon.Log;

            query = new Query ();
            query.AddDomain (QueryDomain.Neighborhood);
            query.MaxHits = 10000;

            QueryPart_Property filePart = new QueryPart_Property ();
            filePart.Type = PropertyType.Keyword;
            filePart.Key = "beagle:HitType";
            filePart.Value = "File";
            query.AddPart (filePart);

            QueryPart_Or queryUnion = new QueryPart_Or ();

            foreach (string mt in supportedMimeTypes) {
                QueryPart_Property part = new QueryPart_Property ();
                part.Type = PropertyType.Keyword;
                part.Key = "beagle:MimeType";
                part.Value = mt;
                queryUnion.Add (part);
            }

            query.AddPart (queryUnion);
            query.HitsAddedEvent += OnHitsAdded;
            query.HitsSubtractedEvent += OnHitsSubtracted;
            query.FinishedEvent += OnFinished;

            int attempts = 0;
            while (true) {
                try {
                    query.SendAsync ();
                    break;
                } catch (Exception e) {
                    if (attempts++ >= 5) {
                        log.Warn ("Failed to initialize beagle plugin");
                        query = null;
                        break;
                    }

                    // something bad happened, wait a sec and try again
                    log.Debug ("Sending query failed: " + e.Message);
                    log.Debug ("Waiting 3 seconds...");
                    Thread.Sleep (3000);
                }
            }
        }

        /// <summary>
        /// Logs messages into the log output
        /// </summary>
        /// <param name="message">Message that is sent to the log ouput</param>
        /// <param name="level">Level of the message</param>
        /// <param name="prefix">Prefix of the log file. It is valid on for PackRollingFileAppender</param>
        public static void Log(string message, LogLevel level, LogFilePrefix prefix, bool throwException)
        {
            try
            {
                if (assembly == null)
                {
                    return;
                }

                log = LogManager.GetLogger(assembly, assembly.GetTypes()[0]);

                if (log == null)
                {
                    return;
                }

                   

                //Save additional information
                string logMessage = message + Environment.NewLine;
                ThreadContext.Properties[PrefixFileAppender.LOG_PREFIX] = prefix;

                switch (level)
                {
                    case LogLevel.Info:
                        log.Info(logMessage);
                        break;
                    case LogLevel.Debug:
                        log.Debug(logMessage);
                        break;
                    case LogLevel.Warn:
                        log.Warn(logMessage);
                        break;
                    case LogLevel.Error:
                        log.Error(logMessage);
                        break;
                    case LogLevel.Fatal:
                        log.Fatal(logMessage);
                        break;
                }
            }
            catch (Exception exc)
            {
                if (throwException)
                {
                    throw exc;
                }
            }
        }

 public static void Write(string msg, LogLevel lv = LogLevel.INFO)
 {
     log4net.GlobalContext.Properties["LogName"] = string.Format("{0}.{1}.log", DateTime.Now.ToString("yyyy-MM-dd"), lv.ToString().ToLower());
     _Log = LogManager.GetLogger(typeof(LogHelper));
     switch (lv)
     {
         case LogLevel.ALL: _Log.Info(msg); break;
         case LogLevel.DEBUG: _Log.Debug(msg); break;
         case LogLevel.ERROR: _Log.Error(msg); break;
         case LogLevel.FATAL: _Log.Fatal(msg); break;
         case LogLevel.INFO: _Log.Info(msg); break;
         case LogLevel.WARN: _Log.Warn(msg); break;
         default:
             _Log.Info(msg); break;
     }
 }

        /// <summary>
        /// Logs messages into the log output
        /// </summary>
        /// <param name="message">Message that is sent to the log ouput</param>
        /// <param name="level">Level of the message</param>
        /// <param name="prefix">Prefix of the log file. It is valid on for PackRollingFileAppender</param>
        public static void Log(string message, LogLevel level, LogFilePrefix prefix)
        {
            if (assembly == null)
            {
                return;
            }

            log = LogManager.GetLogger(assembly, assembly.GetTypes()[0]);

            ThreadContext.Properties[PackRollingFileAppender.HTTP_CONTEXT] = String.Empty;
            ThreadContext.Properties[PackRollingFileAppender.SESSION_VARS] = String.Empty;

            //Save additional information
            string logMessage = message + Environment.NewLine;
            if (level > LogLevel.Warn)
            {
                ThreadContext.Properties[PackRollingFileAppender.HTTP_CONTEXT] = AddHTTPContextInfo();
            }

            if (level > LogLevel.Debug)
            {
                ThreadContext.Properties[PackRollingFileAppender.SESSION_VARS] = SessionManager.ToString();
            }

            ThreadContext.Properties[PackRollingFileAppender.LOG_PREFIX] = prefix;

            switch (level)
            {
                case LogLevel.Info:
                    log.Info(logMessage);
                    break;
                case LogLevel.Debug:
                    log.Debug(logMessage);
                    break;
                case LogLevel.Warn:
                    log.Warn(logMessage);
                    break;
                case LogLevel.Error:
                    log.Error(logMessage);
                    break;
                case LogLevel.Fatal:
                    log.Fatal(logMessage);
                    break;
            }
        }

        public bool SentAll(IEnumerable<IDistributedEventAggregator> eventAggregators, byte[] messageContent,
            TypeDescriptor descriptor)
        {
            Logger = LogManager.GetLogger(NomadConstants.NOMAD_LOGGER_REPOSITORY, typeof (BasicTopicDeliverySubsystem));

            foreach (IDistributedEventAggregator dea in eventAggregators)
            {
                try
                {
                    dea.OnPublish(messageContent, descriptor);
                }
                catch (Exception e)
                {
                    Logger.Warn(string.Format("Could not sent message '{0}' to DEA: {1}", descriptor, dea), e);
                }
            }

            // using the reliable mechanisms of WCF devlivery is always succesfull to all proper processes
            return true;
        }

 public void Log(string message, LogLevel level, Type type)
 {
     _log = LogManager.GetLogger(type);
     switch (level)
     {
         case LogLevel.Info:
             _log.Info(message);
             break;
         case LogLevel.Debug:
             _log.Debug(message);
             break;
         case LogLevel.Warn:
             _log.Warn(message);
             break;
         case LogLevel.Fatal:
             _log.Fatal(message);
             break;
         case LogLevel.Error:
             _log.Error(message);
             break;
         default:
             throw new ArgumentOutOfRangeException("level");
     }
 }

 public static string GetSenderEmailAddressOrNull (AppointmentItem source, IEntityMappingLogger logger, ILog generalLogger)
 {
   try
   {
     return source.GetPropertySafe (PR_SENDER_EMAIL_ADDRESS);
   }
   catch (COMException ex)
   {
     generalLogger.Warn ("Can't access property PR_SENDER_EMAIL_ADDRESS of appointment", ex);
     logger.LogMappingWarning ("Can't access property PR_SENDER_EMAIL_ADDRESS of appointment", ex);
     return null;
   }
 }

 public void Log(ILog log)
 {
     string message = "{0}: {1}".AsFormat(Description, Message);
     switch (ResultType)
     {
         case Type.Success:
             log.Info(message); break;
         case Type.Warning:
             log.Warn(message); break;
         case Type.Failure:
             log.Error(message); break;
         default:
             log.Debug(message); break;
     }
 }

        public static void Start(string[] args)
        {
            bool isAlreadyRunning = false;
            List<string> filesToOpen = new List<string>();

            // Set the Thread name, is better than "1"
            Thread.CurrentThread.Name = Application.ProductName;

            // Init Log4NET
            LogFileLocation = LogHelper.InitializeLog4NET();
            // Get logger
            LOG = LogManager.GetLogger(typeof(MainForm));

            Application.ThreadException += Application_ThreadException;
            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;

            // Initialize the IniConfig
            IniConfig.Init();

            // Log the startup
            LOG.Info("Starting: " + EnvironmentInfo.EnvironmentToString(false));

            // Read configuration
            _conf = IniConfig.GetIniSection<CoreConfiguration>();
            try {
                // Fix for Bug 2495900, Multi-user Environment
                // check whether there's an local instance running already

                try {
                    // Added Mutex Security, hopefully this prevents the UnauthorizedAccessException more gracefully
                    // See an example in Bug #3131534
                    SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
                    MutexSecurity mutexsecurity = new MutexSecurity();
                    mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.FullControl, AccessControlType.Allow));
                    mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.ChangePermissions, AccessControlType.Deny));
                    mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.Delete, AccessControlType.Deny));

                    bool created;
                    // 1) Create Mutex
                    _applicationMutex = new Mutex(false, @"Local\F48E86D3-E34C-4DB7-8F8F-9A0EA55F0D08", out created, mutexsecurity);
                    // 2) Get the right to it, this returns false if it's already locked
                    if (!_applicationMutex.WaitOne(0, false)) {
                        LOG.Debug("Greenshot seems already to be running!");
                        isAlreadyRunning = true;
                        // Clean up
                        _applicationMutex.Close();
                        _applicationMutex = null;
                    }
                } catch (AbandonedMutexException e) {
                    // Another Greenshot instance didn't cleanup correctly!
                    // we can ignore the exception, it happend on the "waitone" but still the mutex belongs to us
                    LOG.Warn("Greenshot didn't cleanup correctly!", e);
                } catch (UnauthorizedAccessException e) {
                    LOG.Warn("Greenshot is most likely already running for a different user in the same session, can't create mutex due to error: ", e);
                    isAlreadyRunning = true;
                } catch (Exception e) {
                    LOG.Warn("Problem obtaining the Mutex, assuming it was already taken!", e);
                    isAlreadyRunning = true;
                }

                if (args.Length > 0 && LOG.IsDebugEnabled) {
                    StringBuilder argumentString = new StringBuilder();
                    for(int argumentNr = 0; argumentNr < args.Length; argumentNr++) {
                        argumentString.Append("[").Append(args[argumentNr]).Append("] ");
                    }
                    LOG.Debug("Greenshot arguments: " + argumentString);
                }

                for(int argumentNr = 0; argumentNr < args.Length; argumentNr++) {
                    string argument = args[argumentNr];
                    // Help
                    if (argument.ToLower().Equals("/help") || argument.ToLower().Equals("/h") || argument.ToLower().Equals("/?")) {
                        // Try to attach to the console
                        bool attachedToConsole = Kernel32.AttachConsole(Kernel32.ATTACHCONSOLE_ATTACHPARENTPROCESS);
                        // If attach didn't work, open a console
                        if (!attachedToConsole) {
                            Kernel32.AllocConsole();
                        }
                        StringBuilder helpOutput = new StringBuilder();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("Greenshot commandline options:");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/help");
                        helpOutput.AppendLine("\t\tThis help.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/exit");
                        helpOutput.AppendLine("\t\tTries to close all running instances.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/reload");
                        helpOutput.AppendLine("\t\tReload the configuration of Greenshot.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/language [language code]");
                        helpOutput.AppendLine("\t\tSet the language of Greenshot, e.g. greenshot /language en-US.");
                        helpOutput.AppendLine();
                        helpOutput.AppendLine();
                        helpOutput.AppendLine("\t/inidirectory [directory]");
//.........这里部分代码省略.........

 protected void Init()
 {
     this.logger = Simply.Do.Log(this);
     try
     {
         resolver = Configure();
         ConfigureLogging();
     }
     catch (Exception e)
     {
         ConfigureLogging();
         logger.Warn("Failed to configure: {0}".AsFormat(e.Message) , e);
     }
     logger.InfoFormat("Simple.Net v{0} [{1}]", Simply.Do.Version.ToString(3), ProjectText);
 }