Question

我对自定义TraceListener有些困难。问题是写一条跟踪线会产生两个调用，一个调用Write（），另一个调用WriteLine（）。对Write（）的调用包含跟踪源，级别和事件ID。对WriteLine（）的调用是实际的消息

看起来跟踪侦听器只被实例化一次，因此我不能将第一次调用排队到Write（）。看起来没有办法关联这两个电话。不幸的是，这是一个问题，因为它导致我向远程服务发送2条消息，使开销加倍。

似乎没有任何通用的方法来过滤调用。我接受只是忽略了源和级别的调用，但看起来这可能非常容易发生。

以下是一段代码示例：

 /// <summary>
 /// When overridden in a derived class, writes the specified message to the listener you create in the derived class.
 /// </summary>
 /// <param name="message">A message to write. </param><filterpriority>2</filterpriority>
 public override void Write(string message)
 {
      _client.Post(message);
 }


 /// <summary>
 /// When overridden in a derived class, writes a message to the listener you create in the derived class, followed by a line terminator.
 /// </summary>
 /// <param name="message">A message to write. </param><filterpriority>2</filterpriority>
 public override void WriteLine(string message)
 {
      _client.Post(message);
 }

用法是：

private static readonly TraceSource Ts = new TraceSource("Source");

Ts.TraceEvent(TraceEventType.Error, 0, "Error Message");

将使用：

生成对Write（）的调用

“来源：错误：0”

然后使用

调用WriteLine（）

“错误讯息”

是否可以合并这两条消息？或者只过滤第一个？谢谢！

Answer 1

有两种不同格式的消息......这些消息写在哪里？这是使用企业日志块吗？如果是这样，你应该检查配置文件 - 监听器可能会被注册两次。

Answer 2

我能够通过从Ukadc Diagnostics

实现TraceListener基类来解决这个问题

基类是：

public abstract class CustomTraceListener : TraceListener
{
    private static readonly TraceSource Trace = new TraceSource("PostmarkTraceListener");

    /// <summary>
    /// Construct an instance of the trace listener
    /// </summary>
    /// <param name="name">The name of the trace listener</param>
    protected CustomTraceListener(string name)
        : base(name)
    {

    }

    #region Abstracts

    /// <summary>
    /// This method must be overriden and forms the core logging method called by all other TraceEvent methods.
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="message">A message to be output regarding the trace event</param>
    protected abstract void TraceEventCore(TraceEventCache eventCache, string source, TraceEventType eventType,
                                           int id, string message);

    /// <summary>
    /// This method must be overriden and forms the core logging method called by all otherTraceData methods.
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="data">The data to be logged</param>
    protected abstract void TraceDataCore(TraceEventCache eventCache, string source, TraceEventType eventType,
                                          int id, params object[] data);

    #endregion

    #region TraceData/TraceEvent Overrides

    /// <summary>
    /// Write a trace event
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="message">A message to be output regarding the trace event</param>
    public override sealed void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType,
                                           int id, string message)
    {
        FilterTraceEventCore(eventCache, source, eventType, id, message);
    }

    /// <summary>
    /// Write a trace event
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="format">A string format specification for the trace event</param>
    /// <param name="args">Arguments used within the format specification string</param>
    public override sealed void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType,
                                           int id, string format, params object[] args)
    {
        string message = string.Format(CultureInfo.CurrentCulture, format, args);

        FilterTraceEventCore(eventCache, source, eventType, id, message);
    }

    /// <summary>
    /// Write a trace event
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    public override sealed void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType,
                                           int id)
    {
        FilterTraceEventCore(eventCache, source, eventType, id, null);
    }

    /// <summary>
    /// Write a trace event
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="data">The data to be written</param>
    public override sealed void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType,
                                          int id, object data)
    {
        FilterTraceDataCore(eventCache, source, eventType, id, data);
    }

    /// <summary>
    /// Write a trace event
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="data">The data to be written</param>
    public override sealed void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType,
                                          int id, params object[] data)
    {
        FilterTraceDataCore(eventCache, source, eventType, id, data);
    }

    #endregion

    #region Write Methods

    /// <summary>
    /// Write a message to the trace listeners
    /// </summary>
    /// <param name="message">The message to write</param>
    public override void Write(string message)
    {
        FilterTraceEventCore(null, string.Empty, TraceEventType.Information, 0, message);
    }

    /// <summary>
    /// Write a message to the trace listeners
    /// </summary>
    /// <param name="message">The message to write</param>
    public override void WriteLine(string message)
    {
        Write(message);
    }

    #endregion

    #region ShouldTrace

    /// <summary>
    /// Determines whether a filter is attached to this listener and, if so, asks whether it ShouldTrace applies to this data.
    /// </summary>
    protected virtual bool ShouldTrace(TraceEventCache eventCache, string source, TraceEventType eventType, int id,
                                       string formatOrMessage, object[] args, object data1, object[] data)
    {
        return !(Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, formatOrMessage, args, data1, data));
    }

    #endregion

    #region FilterTraceCore

    /// <summary>
    /// Called before the main TraceEventCore method and applies any filter by calling ShouldTrace.
    /// </summary>
    protected virtual void FilterTraceEventCore(TraceEventCache eventCache, string source, TraceEventType eventType,
                                                int id, string message)
    {
        try
        {
            if (!ShouldTrace(eventCache, source, eventType, id, message, null, null, null))
                return;

            TraceEventCore(eventCache, source, eventType, id, message);
        }
        catch (Exception exc)
        {
            Trace.TraceEvent(TraceEventType.Error, 0, "{0}", exc);
        }
    }

    /// <summary>
    /// Called before the main TraceDataCore method and applies any filter by calling ShouldTrace.
    /// </summary>
    protected virtual void FilterTraceDataCore(TraceEventCache eventCache, string source, TraceEventType eventType,
                                               int id, params object[] data)
    {
        try
        {
            if (!ShouldTrace(eventCache, source, eventType, id, null, null, null, data))
                return;

            TraceDataCore(eventCache, source, eventType, id, data);
        }
        catch (Exception exc)
        {
            Trace.TraceEvent(TraceEventType.Error, 0, "{0}", exc);
        }
    }

    #endregion
}

和我的自定义TraceListener：

public class PostmarkTraceListener : CustomTraceListener
{
    #region CustomTraceListener Overrides

    /// <summary>
    /// This method must be overriden and forms the core logging method called by all other TraceEvent methods.
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="message">A message to be output regarding the trace event</param>
    protected override void TraceEventCore(TraceEventCache eventCache, string source, TraceEventType eventType,
                                           int id, string message)
    {
        SendPostmarkMessage(eventCache, source, eventType, id, message, null);
    }

    /// <summary>
    /// This method must be overriden and forms the core logging method called by all otherTraceData methods.
    /// </summary>
    /// <param name="eventCache">A cache of data that defines the trace event</param>
    /// <param name="source">The trace source</param>
    /// <param name="eventType">The type of event</param>
    /// <param name="id">The unique ID of the trace event</param>
    /// <param name="data">The data to be logged</param>
    protected override void TraceDataCore(TraceEventCache eventCache, string source, TraceEventType eventType,
                                          int id, params object[] data)
    {
        SendPostmarkMessage(eventCache, source, eventType, id, null, data);
    }

    #endregion

    private void SendPostmarkMessage(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data)
    {
        // do your work here
    }
}

您可以在我的github account

上找到一个有效的例子

自定义TraceListener和多条消息

2 个答案: