C# LoggingEvent.LookupProperty方法代码示例

		private XMS.Core.Logging.ServiceModel.Log CreateLogData(LoggingEvent logEvent)
		{
			XMS.Core.Logging.ServiceModel.Log log = new ServiceModel.Log();

			log.LogTime = logEvent.TimeStamp;
			log.Level = logEvent.Level.ToString();
			log.Message = logEvent.RenderedMessage;
			log.Exception = logEvent.GetExceptionString();
			log.Category = (string)logEvent.LookupProperty("Category");

			log.AppName = RunContext.AppName;
			log.AppVersion = RunContext.AppVersion;
			log.Machine = RunContext.Machine;

			log.UserId = logEvent.Properties.Contains("UserId") ? (int)logEvent.LookupProperty("UserId") : -1;
			log.UserIP = (string)logEvent.LookupProperty("UserIP");

			log.RawUrl = (string)logEvent.LookupProperty("RawUrl");


			log.AgentName = (string)logEvent.LookupProperty("AppAgent-Name");
			log.AgentVersion = (string)logEvent.LookupProperty("AppAgent-Version");
			log.AgentPlatform = (string)logEvent.LookupProperty("AppAgent-Platform");
			log.MobileDeviceManufacturer = (string)logEvent.LookupProperty("AppAgent-MobileDeviceManufacturer");
			log.MobileDeviceModel = (string)logEvent.LookupProperty("AppAgent-MobileDeviceModel");
			log.MobileDeviceId = (string)logEvent.LookupProperty("AppAgent-MobileDeviceId");

			return log;
		}

 /// <summary>
 /// Write the property value to the output
 /// </summary>
 /// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
 /// <param name="loggingEvent">the event being logged</param>
 /// <remarks>
 /// <para>
 /// Writes out the value of a named property. The property name
 /// should be set in the <see cref="log4net.Util.PatternConverter.Option"/>
 /// property.
 /// </para>
 /// <para>
 /// If the <see cref="log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
 /// then all the properties are written as key value pairs.
 /// </para>
 /// </remarks>
 protected override void Convert(TextWriter writer, LoggingEvent loggingEvent)
 {
     if (Option != null)
     {
         // Write the value for the specified key
         WriteObject(writer, loggingEvent.Repository, loggingEvent.LookupProperty(Option));
     }
     else
     {
         // Write all the key value pairs
         WriteDictionary(writer, loggingEvent.Repository, loggingEvent.GetProperties());
     }
 }

        protected override void Convert(TextWriter writer, LoggingEvent loggingEvent)
        {
            string messageId = null;

            // pop the NDC
            log4net.Util.ThreadContextStack ndc = loggingEvent.LookupProperty("NDC") as log4net.Util.ThreadContextStack;
            if (ndc != null && ndc.Count > 0)
            {
                // the NDC represents a context stack, whose levels are separated by whitespace. we will use this as our MessageId.
                messageId = ndc.ToString();
            }

            if (string.IsNullOrEmpty(messageId))
            {
                messageId = "-"; // the NILVALUE
            }
            else
            {
                messageId = messageId.Replace(' ', '.'); // replace spaces with periods
            }

            writer.Write(PrintableAsciiSanitizer.Sanitize(messageId, 32));
        }

        protected override void Append(LoggingEvent loggingEvent)
        {
            var property = loggingEvent.LookupProperty(Config.LogKey) as string;
            var form = Application.OpenForms[FormName];
            TextBox textBox = null;
            TabPage tabControl = null;
            if(property != null)
            {
                tabControl = FindControl(property, form) as TabPage;
            }

            if (tabControl != null)
            {
                textBox = FindControl(TextBoxName, tabControl) as TextBox;
            }

            if (textBox == null)
                return;

            var action = new Action(() =>
            {
                if (textBox.Lines.Count() > 300)
                    textBox.Clear();

                textBox.AppendText(RenderLoggingEvent(loggingEvent));
                textBox.ScrollToCaret();
            });

            if (form.InvokeRequired)
            {
                form.BeginInvoke(action);
            }
            else
            {
                action();
            }
        }

    /// <summary>
    /// This method is called by the <see cref="AppenderSkeleton.DoAppend(LoggingEvent)"/>
    /// method. 
    /// </summary>
    /// <param name="loggingEvent">the event to log</param>
    /// <remarks>
    /// <para>Writes the event to the system event log using the 
    /// <see cref="ApplicationName"/>.</para>
    /// 
    /// <para>If the event has an <c>EventID</c> property (see <see cref="LoggingEvent.Properties"/>)
    /// set then this integer will be used as the event log event id.</para>
    /// 
    /// <para>
    /// There is a limit of 32K characters for an event log message
    /// </para>
    /// </remarks>
    protected override void Append(LoggingEvent loggingEvent) {
      //
      // Write the resulting string to the event log system
      //
      int eventID = 0;

      // Look for the EventLogEventID property
      object eventIDPropertyObj = loggingEvent.LookupProperty("EventID");
      if (eventIDPropertyObj != null)
        if (eventIDPropertyObj is int)
          eventID = (int) eventIDPropertyObj;
        else {
          var eventIDPropertyString = eventIDPropertyObj as string;
          if (eventIDPropertyString != null && eventIDPropertyString.Length > 0) {
            // Read the string property into a number
            int intVal;
            if (SystemInfo.TryParse(eventIDPropertyString, out intVal))
              eventID = intVal;
            else
              ErrorHandler.Error("Unable to parse event ID property [" + eventIDPropertyString + "].");
          }
        }

      // Write to the event log
      try {
        string eventTxt = RenderLoggingEvent(loggingEvent);

        // There is a limit of 32K characters for an event log message
        if (eventTxt.Length > 32000)
          eventTxt = eventTxt.Substring(0, 32000);

        EventLogEntryType entryType = GetEntryType(loggingEvent.Level);

        using (SecurityContext.Impersonate(this))
          EventLog.WriteEntry(m_applicationName, eventTxt, entryType, eventID);
      } catch (Exception ex) {
        ErrorHandler.Error(
          "Unable to write to event log [" + m_logName + "] using source [" + m_applicationName + "]",
          ex);
      }
    }

		/// <summary>
		/// Write the event NDC to the output
		/// </summary>
		/// <param name="writer"><see cref="TextWriter" /> that will receive the formatted result.</param>
		/// <param name="loggingEvent">the event being logged</param>
		/// <remarks>
		/// <para>
		/// As the thread context stacks are now stored in named event properties
		/// this converter simply looks up the value of the <c>NDC</c> property.
		/// </para>
		/// <para>
		/// The <see cref="PropertyPatternConverter"/> should be used instead.
		/// </para>
		/// </remarks>
		override protected void Convert(TextWriter writer, LoggingEvent loggingEvent)
		{
			// Write the value for the specified key
			WriteObject(writer, loggingEvent.Repository, loggingEvent.LookupProperty("NDC"));
		}

		/// <summary>
		/// Check if this filter should allow the event to be logged
		/// </summary>
		/// <param name="loggingEvent">the event being logged</param>
		/// <returns>see remarks</returns>
		/// <remarks>
		/// <para>
		/// The event property for the <see cref="Key"/> is matched against 
		/// the <see cref="StringMatchFilter.StringToMatch"/>.
		/// If the <see cref="StringMatchFilter.StringToMatch"/> occurs as a substring within
		/// the property value then a match will have occurred. If no match occurs
		/// this function will return <see cref="FilterDecision.Neutral"/>
		/// allowing other filters to check the event. If a match occurs then
		/// the value of <see cref="StringMatchFilter.AcceptOnMatch"/> is checked. If it is
		/// true then <see cref="FilterDecision.Accept"/> is returned otherwise
		/// <see cref="FilterDecision.Deny"/> is returned.
		/// </para>
		/// </remarks>
		override public FilterDecision Decide(LoggingEvent loggingEvent) 
		{
			if (loggingEvent == null)
			{
				throw new ArgumentNullException("loggingEvent");
			}

			// Check if we have a key to lookup the event property value with
			if (m_key == null)
			{
				// We cannot filter so allow the filter chain
				// to continue processing
				return FilterDecision.Neutral;
			}

			// Lookup the string to match in from the properties using 
			// the key specified.
			object msgObj = loggingEvent.LookupProperty(m_key);

			// Use an ObjectRenderer to convert the property value to a string
			string msg = loggingEvent.Repository.RendererMap.FindAndRender(msgObj);

			// Check if we have been setup to filter
			if (msg == null || (m_stringToMatch == null && m_regexToMatch == null))
			{
				// We cannot filter so allow the filter chain
				// to continue processing
				return FilterDecision.Neutral;
			}
    
			// Firstly check if we are matching using a regex
			if (m_regexToMatch != null)
			{
				// Check the regex
				if (m_regexToMatch.Match(msg).Success == false)
				{
					// No match, continue processing
					return FilterDecision.Neutral;
				} 

				// we've got a match
				if (m_acceptOnMatch) 
				{
					return FilterDecision.Accept;
				} 
				return FilterDecision.Deny;
			}
			else if (m_stringToMatch != null)
			{
				// Check substring match
				if (msg.IndexOf(m_stringToMatch) == -1) 
				{
					// No match, continue processing
					return FilterDecision.Neutral;
				} 

				// we've got a match
				if (m_acceptOnMatch) 
				{
					return FilterDecision.Accept;
				} 
				return FilterDecision.Deny;
			}
			return FilterDecision.Neutral;
		}

		/* Example log4j schema event

<log4j:event logger="first logger" level="ERROR" thread="Thread-3" timestamp="1051494121460">
  <log4j:message><![CDATA[errormsg 3]]></log4j:message>
  <log4j:NDC><![CDATA[third]]></log4j:NDC>
  <log4j:MDC>
    <log4j:data name="some string" value="some valuethird"/>
  </log4j:MDC>
  <log4j:throwable><![CDATA[java.lang.Exception: someexception-third
 	at org.apache.log4j.chainsaw.Generator.run(Generator.java:94)
]]></log4j:throwable>
  <log4j:locationInfo class="org.apache.log4j.chainsaw.Generator"
method="run" file="Generator.java" line="94"/>
  <log4j:properties>
    <log4j:data name="log4jmachinename" value="windows"/>
    <log4j:data name="log4japp" value="udp-generator"/>
  </log4j:properties>
</log4j:event>

		*/

		/* Since log4j 1.3 the log4j:MDC has been combined into the log4j:properties element */

		/// <summary>
		/// Actually do the writing of the xml
		/// </summary>
		/// <param name="writer">the writer to use</param>
		/// <param name="loggingEvent">the event to write</param>
		/// <remarks>
		/// <para>
		/// Generate XML that is compatible with the log4j schema.
		/// </para>
		/// </remarks>
		override protected void FormatXml(XmlWriter writer, LoggingEvent loggingEvent)
		{
			// Translate logging events for log4j

			// Translate hostname property
			if (loggingEvent.LookupProperty(LoggingEvent.HostNameProperty) != null && 
				loggingEvent.LookupProperty("log4jmachinename") == null)
			{
				loggingEvent.GetProperties()["log4jmachinename"] = loggingEvent.LookupProperty(LoggingEvent.HostNameProperty);
			}

			// translate appdomain name
			if (loggingEvent.LookupProperty("log4japp") == null && 
				loggingEvent.Domain != null && 
				loggingEvent.Domain.Length > 0)
			{
				loggingEvent.GetProperties()["log4japp"] = loggingEvent.Domain;
			}

			// translate identity name
			if (loggingEvent.Identity != null && 
				loggingEvent.Identity.Length > 0 && 
				loggingEvent.LookupProperty(LoggingEvent.IdentityProperty) == null)
			{
				loggingEvent.GetProperties()[LoggingEvent.IdentityProperty] = loggingEvent.Identity;
			}

			// translate user name
			if (loggingEvent.UserName != null && 
				loggingEvent.UserName.Length > 0 && 
				loggingEvent.LookupProperty(LoggingEvent.UserNameProperty) == null)
			{
				loggingEvent.GetProperties()[LoggingEvent.UserNameProperty] = loggingEvent.UserName;
			}

			// Write the start element
			writer.WriteStartElement("log4j:event");
			writer.WriteAttributeString("logger", loggingEvent.LoggerName);

			// Calculate the timestamp as the number of milliseconds since january 1970
			// 
			// We must convert the TimeStamp to UTC before performing any mathematical
			// operations. This allows use to take into account discontinuities
			// caused by daylight savings time transitions.
			TimeSpan timeSince1970 = loggingEvent.TimeStamp.ToUniversalTime() - s_date1970;

			writer.WriteAttributeString("timestamp", XmlConvert.ToString((long)timeSince1970.TotalMilliseconds));
			writer.WriteAttributeString("level", loggingEvent.Level.DisplayName);
			writer.WriteAttributeString("thread", loggingEvent.ThreadName);
    
			// Append the message text
			writer.WriteStartElement("log4j:message");
			Transform.WriteEscapedXmlString(writer, loggingEvent.RenderedMessage,this.InvalidCharReplacement);
			writer.WriteEndElement();

			object ndcObj = loggingEvent.LookupProperty("NDC");
			if (ndcObj != null)
			{
				string valueStr = loggingEvent.Repository.RendererMap.FindAndRender(ndcObj);

				if (valueStr != null && valueStr.Length > 0)
				{
					// Append the NDC text
					writer.WriteStartElement("log4j:NDC");
					Transform.WriteEscapedXmlString(writer, valueStr,this.InvalidCharReplacement);
					writer.WriteEndElement();
				}
//.........这里部分代码省略.........

		/// <summary>
		/// This method is called by the <see cref="AppenderSkeleton.DoAppend(LoggingEvent)"/>
		/// method. 
		/// </summary>
		/// <param name="loggingEvent">the event to log</param>
		/// <remarks>
		/// <para>Writes the event to the system event log using the 
		/// <see cref="ApplicationName"/>.</para>
		/// 
		/// <para>If the event has an <c>EventID</c> property (see <see cref="LoggingEvent.Properties"/>)
		/// set then this integer will be used as the event log event id.</para>
		/// 
		/// <para>
		/// There is a limit of 32K characters for an event log message
		/// </para>
		/// </remarks>
		override protected void Append(LoggingEvent loggingEvent) 
		{
			//
			// Write the resulting string to the event log system
			//
			int eventID = m_eventId;

			// Look for the EventID property
			object eventIDPropertyObj = loggingEvent.LookupProperty("EventID");
			if (eventIDPropertyObj != null)
			{
				if (eventIDPropertyObj is int)
				{
					eventID = (int)eventIDPropertyObj;
				}
				else
				{
					string eventIDPropertyString = eventIDPropertyObj as string;
                    if (eventIDPropertyString == null)
                    {
                        eventIDPropertyString = eventIDPropertyObj.ToString();
                    }
					if (eventIDPropertyString != null && eventIDPropertyString.Length > 0)
					{
						// Read the string property into a number
						int intVal;
						if (SystemInfo.TryParse(eventIDPropertyString, out intVal))
						{
							eventID = intVal;
						}
						else
						{
							ErrorHandler.Error("Unable to parse event ID property [" + eventIDPropertyString + "].");
						}
					}
				}
			}

            short category = m_category;
            // Look for the Category property
            object categoryPropertyObj = loggingEvent.LookupProperty("Category");
            if (categoryPropertyObj != null)
            {
                if (categoryPropertyObj is short)
                {
                    category = (short) categoryPropertyObj;
                }
                else
                {
                    string categoryPropertyString = categoryPropertyObj as string;
                    if (categoryPropertyString == null)
                    {
                        categoryPropertyString = categoryPropertyObj.ToString();
                    }
                    if (categoryPropertyString != null && categoryPropertyString.Length > 0)
                    {
                        // Read the string property into a number
                        short shortVal;
                        if (SystemInfo.TryParse(categoryPropertyString, out shortVal))
                        {
                            category = shortVal;
                        }
                        else
                        {
                            ErrorHandler.Error("Unable to parse event category property [" + categoryPropertyString + "].");
                        }
                    }
                }
            }

			// Write to the event log
			try
			{
				string eventTxt = RenderLoggingEvent(loggingEvent);

				// There is a limit of 32K characters for an event log message
				if (eventTxt.Length > 32000)
				{
					eventTxt = eventTxt.Substring(0, 32000);
				}

				EventLogEntryType entryType = GetEntryType(loggingEvent.Level);

				using(SecurityContext.Impersonate(this))
//.........这里部分代码省略.........

		/// <summary>
		/// Lookup the property for <see cref="Key"/>
		/// </summary>
		/// <param name="loggingEvent">The event to format</param>
		/// <returns>returns property value</returns>
		/// <remarks>
		/// <para>
		/// Looks up and returns the object value of the property
		/// named <see cref="Key"/>. If there is no property defined
		/// with than name then <c>null</c> will be returned.
		/// </para>
		/// </remarks>
		public virtual object Format(LoggingEvent loggingEvent)
		{
			return loggingEvent.LookupProperty(m_key);
		}