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 \ TextWriterTraceListener

SSCLI
  1. //------------------------------------------------------------------------------
  2. // <copyright file="TextWriterTraceListener.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. //------------------------------------------------------------------------------
  16. /*
  17. */
  18. namespace System.Diagnostics
  19. {
  20.     using System;
  21.     using System.IO;
  22.     using System.Text;
  23.     using System.Security.Permissions;
  24.     using System.Runtime.InteropServices;
  25.     using Microsoft.Win32;
  26.     using System.Runtime.Versioning;
  27.    
  28.     /// <devdoc>
  29.     /// <para>Directs tracing or debugging output to
  30.     /// a <see cref='T:System.IO.TextWriter'/> or to a <see cref='T:System.IO.Stream'/>,
  31.     /// such as <see cref='F:System.Console.Out'/> or <see cref='T:System.IO.FileStream'/>.</para>
  32.     /// </devdoc>
  33.     [HostProtection(Synchronization = true)]
  34.     public class TextWriterTraceListener : TraceListener
  35.     {
  36.         internal TextWriter writer;
  37.         string fileName = null;
  38.        
  39.         /// <devdoc>
  40.         /// <para>Initializes a new instance of the <see cref='System.Diagnostics.TextWriterTraceListener'/> class with
  41.         /// <see cref='System.IO.TextWriter'/>
  42.         /// as the output recipient.</para>
  43.         /// </devdoc>
  44.         public TextWriterTraceListener()
  45.         {
  46.         }
  47.        
  48.         /// <devdoc>
  49.         /// <para>Initializes a new instance of the <see cref='System.Diagnostics.TextWriterTraceListener'/> class, using the
  50.         /// stream as the recipient of the debugging and tracing output.</para>
  51.         /// </devdoc>
  52.         public TextWriterTraceListener(Stream stream) : this(stream, string.Empty)
  53.         {
  54.         }
  55.        
  56.         /// <devdoc>
  57.         /// <para>Initializes a new instance of the <see cref='System.Diagnostics.TextWriterTraceListener'/> class with the
  58.         /// specified name and using the stream as the recipient of the debugging and tracing output.</para>
  59.         /// </devdoc>
  60.         public TextWriterTraceListener(Stream stream, string name) : base(name)
  61.         {
  62.             if (stream == null)
  63.                 throw new ArgumentNullException("stream");
  64.             this.writer = new StreamWriter(stream);
  65.         }
  66.        
  67.         /// <devdoc>
  68.         /// <para>Initializes a new instance of the <see cref='System.Diagnostics.TextWriterTraceListener'/> class using the
  69.         /// specified writer as recipient of the tracing or debugging output.</para>
  70.         /// </devdoc>
  71.         public TextWriterTraceListener(TextWriter writer) : this(writer, string.Empty)
  72.         {
  73.         }
  74.        
  75.         /// <devdoc>
  76.         /// <para>Initializes a new instance of the <see cref='System.Diagnostics.TextWriterTraceListener'/> class with the
  77.         /// specified name and using the specified writer as recipient of the tracing or
  78.         /// debugging
  79.         /// output.</para>
  80.         /// </devdoc>
  81.         public TextWriterTraceListener(TextWriter writer, string name) : base(name)
  82.         {
  83.             if (writer == null)
  84.                 throw new ArgumentNullException("writer");
  85.             this.writer = writer;
  86.         }
  87.        
  88.         /// <devdoc>
  89.         /// <para>[To be supplied.]</para>
  90.         /// </devdoc>
  91.         [ResourceExposure(ResourceScope.Machine)]
  92.         public TextWriterTraceListener(string fileName)
  93.         {
  94.             this.fileName = fileName;
  95.         }
  96.        
  97.         /// <devdoc>
  98.         /// <para>[To be supplied.]</para>
  99.         /// </devdoc>
  100.         [ResourceExposure(ResourceScope.Machine)]
  101.         public TextWriterTraceListener(string fileName, string name) : base(name)
  102.         {
  103.             this.fileName = fileName;
  104.         }
  105.        
  106.         /// <devdoc>
  107.         /// <para> Indicates the text writer that receives the tracing
  108.         /// or debugging output.</para>
  109.         /// </devdoc>
  110.         public TextWriter Writer {
  111.             get {
  112.                 EnsureWriter();
  113.                 return writer;
  114.             }
  115.            
  116.             set { writer = value; }
  117.         }
  118.        
  119.         /// <devdoc>
  120.         /// <para>Closes the <see cref='System.Diagnostics.TextWriterTraceListener.Writer'/> so that it no longer
  121.         /// receives tracing or debugging output.</para>
  122.         /// </devdoc>
  123.         public override void Close()
  124.         {
  125.             if (writer != null)
  126.                 writer.Close();
  127.            
  128.             writer = null;
  129.         }
  130.        
  131.         /// <internalonly/>
  132.         /// <devdoc>
  133.         /// </devdoc>
  134.         protected override void Dispose(bool disposing)
  135.         {
  136.             if (disposing)
  137.                 this.Close();
  138.         }
  139.        
  140.         /// <devdoc>
  141.         /// <para>Flushes the output buffer for the <see cref='System.Diagnostics.TextWriterTraceListener.Writer'/>.</para>
  142.         /// </devdoc>
  143.         public override void Flush()
  144.         {
  145.             if (!EnsureWriter())
  146.                 return;
  147.             writer.Flush();
  148.         }
  149.        
  150.         /// <devdoc>
  151.         /// <para>Writes a message
  152.         /// to this instance's <see cref='System.Diagnostics.TextWriterTraceListener.Writer'/>.</para>
  153.         /// </devdoc>
  154.         public override void Write(string message)
  155.         {
  156.             if (!EnsureWriter())
  157.                 return;
  158.             if (NeedIndent)
  159.                 WriteIndent();
  160.             writer.Write(message);
  161.         }
  162.        
  163.         /// <devdoc>
  164.         /// <para>Writes a message
  165.         /// to this instance's <see cref='System.Diagnostics.TextWriterTraceListener.Writer'/> followed by a line terminator. The
  166.         /// default line terminator is a carriage return followed by a line feed (\r\n).</para>
  167.         /// </devdoc>
  168.         public override void WriteLine(string message)
  169.         {
  170.             if (!EnsureWriter())
  171.                 return;
  172.             if (NeedIndent)
  173.                 WriteIndent();
  174.             writer.WriteLine(message);
  175.             NeedIndent = true;
  176.         }
  177.        
  178.         private static Encoding GetEncodingWithFallback(Encoding encoding)
  179.         {
  180.             // Clone it and set the "?" replacement fallback
  181.             Encoding fallbackEncoding = (Encoding)encoding.Clone();
  182.             fallbackEncoding.EncoderFallback = EncoderFallback.ReplacementFallback;
  183.             fallbackEncoding.DecoderFallback = DecoderFallback.ReplacementFallback;
  184.            
  185.             return fallbackEncoding;
  186.         }
  187.        
  188.         // This uses a machine resource, scoped by the fileName variable.
  189.         [ResourceExposure(ResourceScope.None)]
  190.         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  191.         internal bool EnsureWriter()
  192.         {
  193.             bool ret = true;
  194.            
  195.             if (writer == null) {
  196.                 ret = false;
  197.                
  198.                 if (fileName == null)
  199.                     return ret;
  200.                
  201.                 // StreamWriter by default uses UTF8Encoding which will throw on invalid encoding errors.
  202.                 // This can cause the internal StreamWriter's state to be irrecoverable. It is bad for tracing
  203.                 // APIs to throw on encoding errors. Instead, we should provide a "?" replacement fallback
  204.                 // encoding to substitute illegal chars. For ex, In case of high surrogate character
  205.                 // D800-DBFF without a following low surrogate character DC00-DFFF
  206.                 // NOTE: We also need to use an encoding that does't emit BOM whic is StreamWriter's default
  207.                 Encoding noBOMwithFallback = GetEncodingWithFallback(new UTF8Encoding(false));
  208.                
  209.                
  210.                 // To support multiple appdomains/instances tracing to the same file,
  211.                 // we will try to open the given file for append but if we encounter
  212.                 // IO errors, we will prefix the file name with a unique GUID value
  213.                 // and try one more time
  214.                 string fullPath = Path.GetFullPath(fileName);
  215.                 string dirPath = Path.GetDirectoryName(fullPath);
  216.                 string fileNameOnly = Path.GetFileName(fullPath);
  217.                
  218.                 for (int i = 0; i < 2; i++) {
  219.                     try {
  220.                         writer = new StreamWriter(fullPath, true, noBOMwithFallback, 4096);
  221.                         ret = true;
  222.                         break;
  223.                     }
  224.                     catch (IOException) {
  225.                        
  226.                         // Should we do this only for ERROR_SHARING_VIOLATION?
  227.                         //if (InternalResources.MakeErrorCodeFromHR(Marshal.GetHRForException(ioexc)) == InternalResources.ERROR_SHARING_VIOLATION) {
  228.                        
  229.                         fileNameOnly = Guid.NewGuid().ToString() + fileNameOnly;
  230.                         fullPath = Path.Combine(dirPath, fileNameOnly);
  231.                         continue;
  232.                     }
  233.                     catch (UnauthorizedAccessException) {
  234.                         //ERROR_ACCESS_DENIED, mostly ACL issues
  235.                         break;
  236.                     }
  237.                     catch (Exception) {
  238.                         break;
  239.                     }
  240.                 }
  241.                
  242.                 if (!ret) {
  243.                     // Disable tracing to this listener. Every Write will be nop.
  244.                     // We need to think of a central way to deal with the listener
  245.                     // init errors in the future. The default should be that we eat
  246.                     // up any errors from listener and optionally notify the user
  247.                     fileName = null;
  248.                 }
  249.             }
  250.             return ret;
  251.         }
  252.        
  253.     }
  254. }

Developer Fusion