Làm thế nào để phân biệt giữa các cuộc gọi Trace và Debug trong trình theo dõi tùy chỉnh?

Question

Trace.Listeners and Debug.Listists đang chia sẻ cùng một bộ sưu tập nội bộ vì vậy tôi không thể thêm trình theo dõi cho Trace.Listeners và trình lắng nghe gỡ lỗi vào Debug.Listeners để phân biệt giữa chúng.

Tôi làm cách nào để đạt được điều này?

Edit:

Tại sao tôi muốn làm điều này chỉ đơn giản là vì tôi wrting một lớp khai thác gỗ để ứng dụng của chúng tôi và tôi muốn theo dõi các bản ghi khác nhau thông qua các hệ thống nơi Debug/Dấu vết là hai nguồn nhật ký (có một vài nguồn khác nữa) Tôi muốn theo dõi.

Answer 1

[EDIT]

tôi đã bỏ lỡ một phần trong tiêu đề của câu hỏi mà bạn đề cập đến điều này trong bối cảnh của một tùy chỉnh dấu vết người nghe. Vì vậy, dường như bạn đã viết (hoặc muốn viết) một TraceListener tùy chỉnh có thể phân biệt giữa Trace.WriteLine và Debug.WriteLine. Tôi nghĩ rằng tất cả mọi thứ mà tôi nói dưới đây vẫn giữ đúng như xa như TraceSources được ưa thích hơn để Trace.WriteLine và Debug.WriteLine. Tuy nhiên, câu trả lời của tôi không nhất thiết phải trả lời câu hỏi của bạn, ngoại trừ việc nói rằng tôi không nghĩ rằng có thể từ bên trong một phương thức Write và WriteLine của TraceListener để biết liệu chúng có được gọi cuối cùng hay không bởi một lời gọi tới Trace.WriteLine vs Debug .WriteLine.

Nó không rõ ràng những gì bạn đang cố gắng để thực hiện, ngay cả khi bạn có thể nói từ trong TraceListener tùy chỉnh nguồn cuối cùng của cuộc gọi để viết hoặc WriteLine. Bất cứ điều gì bạn muốn thực hiện, tôi phải tin rằng sẽ dễ dàng hơn nếu bạn dựa vào các câu lệnh ghi nhật ký trong mã của bạn trên TraceSources để bắt đầu.

Bạn có thể thêm một số mã vào câu hỏi ban đầu cho biết cách bạn có thể viết một số mã ứng dụng, thêm một số cuộc gọi vào Trace.WriteLine và Debug.WriteLine. Ngoài ra, hiển thị một số mã từ TraceListener tùy chỉnh của bạn cho thấy hành động bạn muốn thực hiện nếu bạn có thể phân biệt giữa Trace.WriteLine và Debug.WriteLine. Một cái gì đó như:

public void WriteLine(string msg) 
{ 
    if (WasWrittenFromTrace) 
    { 
    //Before writing to output, add "TRACE" to front of message 
    WriteToOutput("TRACE: {0}", msg); 
    } 
    else 
    if (WasWrittenFromDebug) 
    { 
    //Before writing to output, add "DEBUG" to front of message 
    WriteToOutput("DEBUG: {0}", msg); 
    } 
} 

[END EDIT]

Xem this answer tôi đăng gần đây để đáp ứng với một câu hỏi về việc sử dụng System.Diagnostics.

Có rất nhiều thông tin ở đó và rất nhiều thông tin trong liên kết trong câu trả lời đó về cách sử dụng System.Diagnostics, chú trọng vào việc sử dụng TraceSources thay vì Trace.WriteLine và Debug.WriteLine.

Từ câu hỏi của bạn, có vẻ như bạn có thể muốn viết một số mã như thế này:

public void MyFunction(int x, int y) 
{ 
    Trace.WriteLine("Entering MyFunction. x = {0}, y = {1}", x, y); 

    int product = x * y; 

    Debug.WriteLine("product = {0}", product); 

    Trace.WriteLine("Exiting MyFunction"); 
} 

VÀ bạn sẽ rõ ràng như sản lượng vết để đi đến một TraceListener và đầu ra Debug để đi đến TraceListener khác . HOẶC trong một TraceListener (có thể bạn sẽ tự viết), bạn muốn có thể biết một Write/WriteLine đã cho có thực sự là một Trace.Write hay Debug.Write hay không. Tôi không nghĩ rằng đó là thực sự có thể.

Bạn cũng muốn kiểm soát đầu ra Trace and Debug theo các cách khác (có thể bật và tắt một lần?

Nếu bạn sử dụng TraceSources, bạn có thể dễ dàng kiểm soát mức truy tìm/ghi nhật ký và bạn có thể, nếu bạn muốn, hãy gửi đầu ra của một số TraceSources đến một TraceListener và đầu ra của một TraceListener (và một số TraceSources thậm chí có thể ghi vào nhiều TraceListeners).

Vì vậy, sử dụng TraceSources, bạn có thể viết mã như thế này:

public class MyClass 
{ 
    //Static variable, so all instances of MyClass will have access to the same instance 
    //of the TraceSource 
    private static readonly TraceSource ts = new TraceSource("MyClass"); 

    public void MyMethod(int x, int y) 
    { 
    ts.TraceEvent(TraceEventType.Information, 0, "Entering MyMethod. x = {0}, y = {1}", x, y); 

    int product = x * y; 

    ts.TraceEvent(TraceEventType.Debug, 0, "Product = {0}", product); 

    ts.TraceEvent(TraceEventType.Information, 0, "Exiting MyMethod."); 
    } 
} 

những lợi ích của TraceSource trong ví dụ này là gì?

1. Trong app.config của bạn, bạn có thể bật hoặc tắt "MyClass" TraceSource hoặc đặt ở một mức nhất định. Nếu bạn đặt nó thành "Gỡ lỗi", thông báo Gỡ lỗi và Thông tin sẽ được viết. Nếu bạn đặt nó thành "Thông tin", chỉ các thông báo Thông tin mới được ghi lại. Nếu bạn đặt cao hơn "Thông tin", không có thông báo nào trong ví dụ sẽ được ghi lại.

2. Trong app.config của bạn, bạn có thể gửi đầu ra của "MyClass" đến một hoặc nhiều TraceListeners. Nếu bạn có nhiều TraceSources ("YourClass", "HisClass"), mỗi TraceListener có thể đi tới TraceListener tương tự hoặc mỗi TraceListener có thể đi tới TraceListener của riêng nó hoặc bất kỳ sự kết hợp nào ở giữa.

3. Trong app.config của bạn, bạn có thể thiết lập switching và/hoặc filtering sao cho "MyClass" được chỉ định truy cập, ví dụ: hai TraceListeners. Một TraceListener có thể lọc như vậy mà chỉ có "Debug" tin nhắn được đăng nhập và người kia có thể lọc như vậy mà chỉ có "Thông tin" tin nhắn được đăng nhập.

Có rất nhiều điều bạn có thể làm với TraceSources. Đọc liên kết ở trên và các liên kết bên trong bài đăng đó. Xem dự án Ukadc.Diagnostics mà tôi tham chiếu trong bài đăng. Essential.Diagnostics là một dự án khác cung cấp phần mở rộng cho System.Diagnostics cũng như hiển thị một số ví dụ khá hay về việc sử dụng System.Diagnostics. Here is a good example from MSDN about using TraceSources, filters, and TraceListeners.

Theo tôi, bạn sẽ tốt hơn nếu bạn cố gắng sử dụng TraceSources thay vì Trace. * Và Debug. * Để thêm truy tìm/đăng nhập vào mã của bạn.

Chúc may mắn!