We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ DelimitedListTraceListener

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="DelimitedListTraceListener.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  17. using System;
  18. using System.Text;
  19. using System.Globalization;
  20. using System.IO;
  21. using System.Collections;
  22. using System.Security.Permissions;
  23. using System.Runtime.Versioning;
  25. namespace System.Diagnostics
  26. {
  27.     [HostProtection(Synchronization = true)]
  28.     public class DelimitedListTraceListener : TextWriterTraceListener
  29.     {
  30.         string delimiter = ";";
  31.         string secondaryDelim = ",";
  32.         bool initializedDelim = false;
  33.        
  34.         public DelimitedListTraceListener(Stream stream) : base(stream)
  35.         {
  36.         }
  37.        
  38.         public DelimitedListTraceListener(Stream stream, string name) : base(stream, name)
  39.         {
  40.         }
  41.        
  42.         public DelimitedListTraceListener(TextWriter writer) : base(writer)
  43.         {
  44.         }
  45.        
  46.         public DelimitedListTraceListener(TextWriter writer, string name) : base(writer, name)
  47.         {
  48.         }
  49.        
  50.         [ResourceExposure(ResourceScope.Machine)]
  51.         [ResourceConsumption(ResourceScope.Machine)]
  52.         public DelimitedListTraceListener(string fileName) : base(fileName)
  53.         {
  54.         }
  55.        
  56.         [ResourceExposure(ResourceScope.Machine)]
  57.         [ResourceConsumption(ResourceScope.Machine)]
  58.         public DelimitedListTraceListener(string fileName, string name) : base(fileName, name)
  59.         {
  60.         }
  61.        
  62.         public string Delimiter {
  63.             get {
  64.                 lock (this) {
  65.                     // Probably overkill
  66.                     if (!initializedDelim) {
  67.                        
  68.                         if (Attributes.ContainsKey("delimiter"))
  69.                             delimiter = Attributes["delimiter"];
  70.                        
  71.                         initializedDelim = true;
  72.                     }
  73.                 }
  74.                 return delimiter;
  75.             }
  76.             set {
  77.                 if (value == null)
  78.                     throw new ArgumentNullException("Delimiter");
  79.                
  80.                 if (value.Length == 0)
  81.                     throw new ArgumentException(SR.GetString("Generic_ArgCantBeEmptyString", "Delimiter"));
  82.                
  83.                 lock (this) {
  84.                     delimiter = value;
  85.                     initializedDelim = true;
  86.                 }
  87.                
  88.                 if (delimiter == ",")
  89.                     secondaryDelim = ";";
  90.                 else
  91.                     secondaryDelim = ",";
  92.             }
  93.         }
  94.        
  95.         protected internal override string[] GetSupportedAttributes()
  96.         {
  97.             return new string[] {"delimiter"};
  98.         }
  99.        
  100.        
  101.         public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args)
  102.         {
  103.             if (Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, format, args))
  104.                 return;
  105.            
  106.             WriteHeader(source, eventType, id);
  107.            
  108.             if (args != null)
  109.                 WriteEscaped(String.Format(CultureInfo.InvariantCulture, format, args));
  110.             else
  111.                 WriteEscaped(format);
  112.             Write(Delimiter);
  113.             // Use get_Delimiter
  114.             // one more delimiter for the data object
  115.             Write(Delimiter);
  116.             // Use get_Delimiter
  117.             WriteFooter(eventCache);
  118.         }
  119.        
  120.         public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
  121.         {
  122.             if (Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, message))
  123.                 return;
  124.            
  125.             WriteHeader(source, eventType, id);
  126.            
  127.             WriteEscaped(message);
  128.             Write(Delimiter);
  129.             // Use get_Delimiter
  130.             // one more delimiter for the data object
  131.             Write(Delimiter);
  132.             // Use get_Delimiter
  133.             WriteFooter(eventCache);
  134.         }
  135.        
  136.         public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
  137.         {
  138.             if (Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, null, null, data))
  139.                 return;
  140.            
  141.             WriteHeader(source, eventType, id);
  142.            
  143.             // first a delimiter for the message
  144.             Write(Delimiter);
  145.             // Use get_Delimiter
  146.             WriteEscaped(data.ToString());
  147.             Write(Delimiter);
  148.             // Use get_Delimiter
  149.             WriteFooter(eventCache);
  150.         }
  151.        
  152.         public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data)
  153.         {
  154.             if (Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, null, null, null, data))
  155.                 return;
  156.            
  157.             WriteHeader(source, eventType, id);
  158.            
  159.             // first a delimiter for the message
  160.             Write(Delimiter);
  161.             // Use get_Delimiter
  162.             if (data != null) {
  163.                 for (int i = 0; i < data.Length; i++) {
  164.                     if (i != 0)
  165.                         Write(secondaryDelim);
  166.                     WriteEscaped(data[i].ToString());
  167.                 }
  168.             }
  169.             Write(Delimiter);
  170.             // Use get_Delimiter
  171.             WriteFooter(eventCache);
  172.         }
  173.        
  174.         private void WriteHeader(string source, TraceEventType eventType, int id)
  175.         {
  176.             WriteEscaped(source);
  177.             Write(Delimiter);
  178.             // Use get_Delimiter
  179.             Write(eventType.ToString());
  180.             Write(Delimiter);
  181.             // Use get_Delimiter
  182.             Write(id.ToString(CultureInfo.InvariantCulture));
  183.             Write(Delimiter);
  184.             // Use get_Delimiter
  185.         }
  186.        
  187.         private void WriteFooter(TraceEventCache eventCache)
  188.         {
  189.             if (eventCache != null) {
  190.                 if (IsEnabled(TraceOptions.ProcessId))
  191.                     Write(eventCache.ProcessId.ToString(CultureInfo.InvariantCulture));
  192.                 Write(Delimiter);
  193.                 // Use get_Delimiter
  194.                 if (IsEnabled(TraceOptions.LogicalOperationStack))
  195.                     WriteStackEscaped(eventCache.LogicalOperationStack);
  196.                 Write(Delimiter);
  197.                 // Use get_Delimiter
  198.                 if (IsEnabled(TraceOptions.ThreadId))
  199.                     WriteEscaped(eventCache.ThreadId.ToString(CultureInfo.InvariantCulture));
  200.                 Write(Delimiter);
  201.                 // Use get_Delimiter
  202.                 if (IsEnabled(TraceOptions.DateTime))
  203.                     WriteEscaped(eventCache.DateTime.ToString("o", CultureInfo.InvariantCulture));
  204.                 Write(Delimiter);
  205.                 // Use get_Delimiter
  206.                 if (IsEnabled(TraceOptions.Timestamp))
  207.                     Write(eventCache.Timestamp.ToString(CultureInfo.InvariantCulture));
  208.                 Write(Delimiter);
  209.                 // Use get_Delimiter
  210.                 if (IsEnabled(TraceOptions.Callstack))
  211.                     WriteEscaped(eventCache.Callstack);
  212.             }
  213.             else {
  214.                 for (int i = 0; i < 5; i++)
  215.                     Write(Delimiter);
  216.                 // Use get_Delimiter
  217.             }
  218.            
  219.             WriteLine("");
  220.         }
  221.        
  222.         private void WriteEscaped(string message)
  223.         {
  224.             if (!String.IsNullOrEmpty(message)) {
  225.                 StringBuilder sb = new StringBuilder("\"");
  226.                 int index;
  227.                 int lastindex = 0;
  228.                 while ((index = message.IndexOf('"', lastindex)) != -1) {
  229.                     sb.Append(message, lastindex, index - lastindex);
  230.                     sb.Append("\"\"");
  231.                     lastindex = index + 1;
  232.                 }
  233.                
  234.                 sb.Append(message, lastindex, message.Length - lastindex);
  235.                 sb.Append("\"");
  236.                 Write(sb.ToString());
  237.             }
  238.         }
  239.        
  240.         private void WriteStackEscaped(Stack stack)
  241.         {
  242.             StringBuilder sb = new StringBuilder("\"");
  243.             bool first = true;
  244.             foreach (object obj in stack) {
  245.                 if (!first)
  246.                     sb.Append(", ");
  247.                 else
  248.                     first = false;
  249.                
  250.                 string operation = obj.ToString();
  251.                
  252.                 int index;
  253.                 int lastindex = 0;
  254.                 while ((index = operation.IndexOf('"', lastindex)) != -1) {
  255.                     sb.Append(operation, lastindex, index - lastindex);
  256.                     sb.Append("\"\"");
  257.                     lastindex = index + 1;
  258.                 }
  259.                
  260.                 sb.Append(operation, lastindex, operation.Length - lastindex);
  261.             }
  262.             sb.Append("\"");
  263.             Write(sb.ToString());
  264.         }
  265.        
  266.     }
  267. }

Developer Fusion