The Labs \ Source Viewer \ SSCLI \ System.IO \ NullTextWriter

  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class:  TextWriter
  18. **
  19. **
  20. ** Purpose: Abstract base class for Text-only Writers.
  21. ** Subclasses will include StreamWriter & StringWriter.
  22. **
  23. **
  24. ===========================================================*/
  25. using System;
  26. using System.Text;
  27. using System.Threading;
  28. using System.Runtime.CompilerServices;
  29. using System.Reflection;
  30. using System.Security.Permissions;
  31. using System.Globalization;
  32. namespace System.IO
  33. {
  34.     // This abstract base class represents a writer that can write a sequential
  35.     // stream of characters. A subclass must minimally implement the
  36.     // Write(char) method.
  37.     //
  38.     // This class is intended for character output, not bytes.
  39.     // There are methods on the Stream class for writing bytes.
  40.     [Serializable()]
  41.     [System.Runtime.InteropServices.ComVisible(true)]
  42.     public abstract class TextWriter : MarshalByRefObject, IDisposable
  43.     {
  44.         public static readonly TextWriter Null = new NullTextWriter();
  45.        
  46.         // This should be initialized to Environment.NewLine, but
  47.         // to avoid loading Environment unnecessarily so I've duplicated
  48.         // the value here.
  49.         #if !PLATFORM_UNIX
  50.         private const string InitialNewLine = "\r\n";
  51.        
  52.         protected char[] CoreNewLine = new char[] {'\r', '\n'};
  53.         #else
  54.         private const string InitialNewLine = "\n";
  55.        
  56.         protected char[] CoreNewLine = new char[] {'\n'};
  57.        
  58.         #endif // !PLATFORM_UNIX
  59.        
  60.         // Can be null - if so, ask for the Thread's CurrentCulture every time.
  61.         private IFormatProvider InternalFormatProvider;
  62.        
  63.         protected TextWriter()
  64.         {
  65.             InternalFormatProvider = null;
  66.             // Ask for CurrentCulture all the time.
  67.         }
  68.        
  69.         protected TextWriter(IFormatProvider formatProvider)
  70.         {
  71.             InternalFormatProvider = formatProvider;
  72.         }
  73.        
  74.         public virtual IFormatProvider FormatProvider {
  75.             get {
  76.                 if (InternalFormatProvider == null)
  77.                     return Thread.CurrentThread.CurrentCulture;
  78.                 else
  79.                     return InternalFormatProvider;
  80.             }
  81.         }
  82.        
  83.         // Closes this TextWriter and releases any system resources associated with the
  84.         // TextWriter. Following a call to Close, any operations on the TextWriter
  85.         // may raise exceptions. This default method is empty, but descendant
  86.         // classes can override the method to provide the appropriate
  87.         // functionality.
  88.         public virtual void Close()
  89.         {
  90.             Dispose(true);
  91.             GC.SuppressFinalize(this);
  92.         }
  93.        
  94.         protected virtual void Dispose(bool disposing)
  95.         {
  96.         }
  97.        
  98.        
  99.         public void Dispose()
  100.         {
  101.             Dispose(true);
  102.             GC.SuppressFinalize(this);
  103.         }
  104.        
  105.         // Clears all buffers for this TextWriter and causes any buffered data to be
  106.         // written to the underlying device. This default method is empty, but
  107.         // descendant classes can override the method to provide the appropriate
  108.         // functionality.
  109.         public virtual void Flush()
  110.         {
  111.         }
  112.        
  113.         public abstract Encoding Encoding {
  114.             get;
  115.         }
  116.        
  117.         // Returns the line terminator string used by this TextWriter. The default line
  118.         // terminator string is a carriage return followed by a line feed ("\r\n").
  119.         //
  120.         // Sets the line terminator string for this TextWriter. The line terminator
  121.         // string is written to the text stream whenever one of the
  122.         // WriteLine methods are called. In order for text written by
  123.         // the TextWriter to be readable by a TextReader, only one of the following line
  124.         // terminator strings should be used: "\r", "\n", or "\r\n".
  125.         //
  126.         public virtual string NewLine {
  127.             get { return new string(CoreNewLine); }
  128.             set {
  129.                 if (value == null)
  130.                     value = InitialNewLine;
  131.                 CoreNewLine = value.ToCharArray();
  132.             }
  133.         }
  134.        
  135.        
  136.         [HostProtection(Synchronization = true)]
  137.         public static TextWriter Synchronized(TextWriter writer)
  138.         {
  139.             if (writer == null)
  140.                 throw new ArgumentNullException("writer");
  141.             if (writer is SyncTextWriter)
  142.                 return writer;
  143.            
  144.             return new SyncTextWriter(writer);
  145.         }
  146.        
  147.         // Writes a character to the text stream. This default method is empty,
  148.         // but descendant classes can override the method to provide the
  149.         // appropriate functionality.
  150.         //
  151.         public virtual void Write(char value)
  152.         {
  153.         }
  154.        
  155.         // Writes a character array to the text stream. This default method calls
  156.         // Write(char) for each of the characters in the character array.
  157.         // If the character array is null, nothing is written.
  158.         //
  159.         public virtual void Write(char[] buffer)
  160.         {
  161.             if (buffer != null)
  162.                 Write(buffer, 0, buffer.Length);
  163.         }
  164.        
  165.         // Writes a range of a character array to the text stream. This method will
  166.         // write count characters of data into this TextWriter from the
  167.         // buffer character array starting at position index.
  168.         //
  169.         public virtual void Write(char[] buffer, int index, int count)
  170.         {
  171.             if (buffer == null)
  172.                 throw new ArgumentNullException("buffer", Environment.GetResourceString("ArgumentNull_Buffer"));
  173.             if (index < 0)
  174.                 throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  175.             if (count < 0)
  176.                 throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  177.             if (buffer.Length - index < count)
  178.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  179.            
  180.             for (int i = 0; i < count; i++)
  181.                 Write(buffer[index + i]);
  182.         }
  183.        
  184.         // Writes the text representation of a boolean to the text stream. This
  185.         // method outputs either Boolean.TrueString or Boolean.FalseString.
  186.         //
  187.         public virtual void Write(bool value)
  188.         {
  189.             Write(value ? Boolean.TrueLiteral : Boolean.FalseLiteral);
  190.         }
  191.        
  192.         // Writes the text representation of an integer to the text stream. The
  193.         // text representation of the given value is produced by calling the
  194.         // Int32.ToString() method.
  195.         //
  196.         public virtual void Write(int value)
  197.         {
  198.             Write(value.ToString(FormatProvider));
  199.         }
  200.        
  201.         // Writes the text representation of an integer to the text stream. The
  202.         // text representation of the given value is produced by calling the
  203.         // UInt32.ToString() method.
  204.         //
  205.         [CLSCompliant(false)]
  206.         public virtual void Write(uint value)
  207.         {
  208.             Write(value.ToString(FormatProvider));
  209.         }
  210.        
  211.         // Writes the text representation of a long to the text stream. The
  212.         // text representation of the given value is produced by calling the
  213.         // Int64.ToString() method.
  214.         //
  215.         public virtual void Write(long value)
  216.         {
  217.             Write(value.ToString(FormatProvider));
  218.         }
  219.        
  220.         // Writes the text representation of an unsigned long to the text
  221.         // stream. The text representation of the given value is produced
  222.         // by calling the UInt64.ToString() method.
  223.         //
  224.         [CLSCompliant(false)]
  225.         public virtual void Write(ulong value)
  226.         {
  227.             Write(value.ToString(FormatProvider));
  228.         }
  229.        
  230.         // Writes the text representation of a float to the text stream. The
  231.         // text representation of the given value is produced by calling the
  232.         // Float.toString(float) method.
  233.         //
  234.         public virtual void Write(float value)
  235.         {
  236.             Write(value.ToString(FormatProvider));
  237.         }
  238.        
  239.         // Writes the text representation of a double to the text stream. The
  240.         // text representation of the given value is produced by calling the
  241.         // Double.toString(double) method.
  242.         //
  243.         public virtual void Write(double value)
  244.         {
  245.             Write(value.ToString(FormatProvider));
  246.         }
  247.        
  248.         public virtual void Write(decimal value)
  249.         {
  250.             Write(value.ToString(FormatProvider));
  251.         }
  252.        
  253.         // Writes a string to the text stream. If the given string is null, nothing
  254.         // is written to the text stream.
  255.         //
  256.         public virtual void Write(string value)
  257.         {
  258.             if (value != null)
  259.                 Write(value.ToCharArray());
  260.         }
  261.        
  262.         // Writes the text representation of an object to the text stream. If the
  263.         // given object is null, nothing is written to the text stream.
  264.         // Otherwise, the object's ToString method is called to produce the
  265.         // string representation, and the resulting string is then written to the
  266.         // output stream.
  267.         //
  268.         public virtual void Write(object value)
  269.         {
  270.             if (value != null) {
  271.                 IFormattable f = value as IFormattable;
  272.                 if (f != null)
  273.                     Write(f.ToString(null, FormatProvider));
  274.                 else
  275.                     Write(value.ToString());
  276.             }
  277.         }
  278.        
  279.        
  280.        
  281.         // Writes out a formatted string. Uses the same semantics as
  282.         // String.Format.
  283.         //
  284.         public virtual void Write(string format, object arg0)
  285.         {
  286.             Write(String.Format(FormatProvider, format, arg0));
  287.         }
  288.        
  289.         // Writes out a formatted string. Uses the same semantics as
  290.         // String.Format.
  291.         //
  292.         public virtual void Write(string format, object arg0, object arg1)
  293.         {
  294.             Write(String.Format(FormatProvider, format, arg0, arg1));
  295.         }
  296.        
  297.         // Writes out a formatted string. Uses the same semantics as
  298.         // String.Format.
  299.         //
  300.         public virtual void Write(string format, object arg0, object arg1, object arg2)
  301.         {
  302.             Write(String.Format(FormatProvider, format, arg0, arg1, arg2));
  303.         }
  304.        
  305.         // Writes out a formatted string. Uses the same semantics as
  306.         // String.Format.
  307.         //
  308.         public virtual void Write(string format, params object[] arg)
  309.         {
  310.             Write(String.Format(FormatProvider, format, arg));
  311.         }
  312.        
  313.        
  314.         // Writes a line terminator to the text stream. The default line terminator
  315.         // is a carriage return followed by a line feed ("\r\n"), but this value
  316.         // can be changed by setting the NewLine property.
  317.         //
  318.         public virtual void WriteLine()
  319.         {
  320.             Write(CoreNewLine);
  321.         }
  322.        
  323.         // Writes a character followed by a line terminator to the text stream.
  324.         //
  325.         public virtual void WriteLine(char value)
  326.         {
  327.             Write(value);
  328.             WriteLine();
  329.         }
  330.        
  331.         // Writes an array of characters followed by a line terminator to the text
  332.         // stream.
  333.         //
  334.         public virtual void WriteLine(char[] buffer)
  335.         {
  336.             Write(buffer);
  337.             WriteLine();
  338.         }
  339.        
  340.         // Writes a range of a character array followed by a line terminator to the
  341.         // text stream.
  342.         //
  343.         public virtual void WriteLine(char[] buffer, int index, int count)
  344.         {
  345.             Write(buffer, index, count);
  346.             WriteLine();
  347.         }
  348.        
  349.         // Writes the text representation of a boolean followed by a line
  350.         // terminator to the text stream.
  351.         //
  352.         public virtual void WriteLine(bool value)
  353.         {
  354.             Write(value);
  355.             WriteLine();
  356.         }
  357.        
  358.         // Writes the text representation of an integer followed by a line
  359.         // terminator to the text stream.
  360.         //
  361.         public virtual void WriteLine(int value)
  362.         {
  363.             Write(value);
  364.             WriteLine();
  365.         }
  366.        
  367.         // Writes the text representation of an unsigned integer followed by
  368.         // a line terminator to the text stream.
  369.         //
  370.         [CLSCompliant(false)]
  371.         public virtual void WriteLine(uint value)
  372.         {
  373.             Write(value);
  374.             WriteLine();
  375.         }
  376.        
  377.         // Writes the text representation of a long followed by a line terminator
  378.         // to the text stream.
  379.         //
  380.         public virtual void WriteLine(long value)
  381.         {
  382.             Write(value);
  383.             WriteLine();
  384.         }
  385.        
  386.         // Writes the text representation of an unsigned long followed by
  387.         // a line terminator to the text stream.
  388.         //
  389.         [CLSCompliant(false)]
  390.         public virtual void WriteLine(ulong value)
  391.         {
  392.             Write(value);
  393.             WriteLine();
  394.         }
  395.        
  396.         // Writes the text representation of a float followed by a line terminator
  397.         // to the text stream.
  398.         //
  399.         public virtual void WriteLine(float value)
  400.         {
  401.             Write(value);
  402.             WriteLine();
  403.         }
  404.        
  405.         // Writes the text representation of a double followed by a line terminator
  406.         // to the text stream.
  407.         //
  408.         public virtual void WriteLine(double value)
  409.         {
  410.             Write(value);
  411.             WriteLine();
  412.         }
  413.        
  414.         public virtual void WriteLine(decimal value)
  415.         {
  416.             Write(value);
  417.             WriteLine();
  418.         }
  419.        
  420.         // Writes a string followed by a line terminator to the text stream.
  421.         //
  422.         public virtual void WriteLine(string value)
  423.         {
  424.            
  425.             if (value == null) {
  426.                 WriteLine();
  427.             }
  428.             else {
  429.                 // We'd ideally like WriteLine to be atomic, in that one call
  430.                 // to WriteLine equals one call to the OS (ie, so writing to
  431.                 // console while simultaneously calling printf will guarantee we
  432.                 // write out a string and new line chars, without any interference).
  433.                 // Additionally, we need to call ToCharArray on Strings anyways,
  434.                 // so allocating a char[] here isn't any worse than what we were
  435.                 // doing anyways. We do reduce the number of calls to the
  436.                 // backing store this way, potentially.
  437.                 int vLen = value.Length;
  438.                 int nlLen = CoreNewLine.Length;
  439.                 char[] chars = new char[vLen + nlLen];
  440.                 value.CopyTo(0, chars, 0, vLen);
  441.                 // CoreNewLine will almost always be 2 chars, and possibly 1.
  442.                 if (nlLen == 2) {
  443.                     chars[vLen] = CoreNewLine[0];
  444.                     chars[vLen + 1] = CoreNewLine[1];
  445.                 }
  446.                 else if (nlLen == 1)
  447.                     chars[vLen] = CoreNewLine[0];
  448.                 else
  449.                     Buffer.InternalBlockCopy(CoreNewLine, 0, chars, vLen * 2, nlLen * 2);
  450.                 Write(chars, 0, vLen + nlLen);
  451.             }
  452.             /*
  453.             Write(value);  // We could call Write(String) on StreamWriter...
  454.             WriteLine();
  455.             */           
  456.         }
  457.        
  458.         // Writes the text representation of an object followed by a line
  459.         // terminator to the text stream.
  460.         //
  461.         public virtual void WriteLine(object value)
  462.         {
  463.             if (value == null) {
  464.                 WriteLine();
  465.             }
  466.             else {
  467.                 // Call WriteLine(value.ToString), not Write(Object), WriteLine().
  468.                 // This makes calls to WriteLine(Object) atomic.
  469.                 IFormattable f = value as IFormattable;
  470.                 if (f != null)
  471.                     WriteLine(f.ToString(null, FormatProvider));
  472.                 else
  473.                     WriteLine(value.ToString());
  474.             }
  475.         }
  476.        
  477.        
  478.         // Writes out a formatted string and a new line. Uses the same
  479.         // semantics as String.Format.
  480.         //
  481.         public virtual void WriteLine(string format, object arg0)
  482.         {
  483.             WriteLine(String.Format(FormatProvider, format, arg0));
  484.         }
  485.        
  486.         // Writes out a formatted string and a new line. Uses the same
  487.         // semantics as String.Format.
  488.         //
  489.         public virtual void WriteLine(string format, object arg0, object arg1)
  490.         {
  491.             WriteLine(String.Format(FormatProvider, format, arg0, arg1));
  492.         }
  493.        
  494.         // Writes out a formatted string and a new line. Uses the same
  495.         // semantics as String.Format.
  496.         //
  497.         public virtual void WriteLine(string format, object arg0, object arg1, object arg2)
  498.         {
  499.             WriteLine(String.Format(FormatProvider, format, arg0, arg1, arg2));
  500.         }
  501.        
  502.         // Writes out a formatted string and a new line. Uses the same
  503.         // semantics as String.Format.
  504.         //
  505.         public virtual void WriteLine(string format, params object[] arg)
  506.         {
  507.             WriteLine(String.Format(FormatProvider, format, arg));
  508.         }
  509.        
  510.         [Serializable()]
  511.         private sealed class NullTextWriter : TextWriter
  512.         {
  513.             internal NullTextWriter() : base(CultureInfo.InvariantCulture)
  514.             {
  515.             }
  516.            
  517.             public override Encoding Encoding {
  518.                 get { return Encoding.Default; }
  519.             }
  520.            
  521.             public override void Write(char[] buffer, int index, int count)
  522.             {
  523.             }
  524.            
  525.             public override void Write(string value)
  526.             {
  527.             }
  528.            
  529.             // Not strictly necessary, but for perf reasons
  530.             public override void WriteLine()
  531.             {
  532.             }
  533.            
  534.             // Not strictly necessary, but for perf reasons
  535.             public override void WriteLine(string value)
  536.             {
  537.             }
  538.            
  539.             public override void WriteLine(object value)
  540.             {
  541.             }
  542.         }
  543.        
  544.         [Serializable()]
  545.         internal sealed class SyncTextWriter : TextWriter, IDisposable
  546.         {
  547.             private TextWriter _out;
  548.            
  549.             internal SyncTextWriter(TextWriter t) : base(t.FormatProvider)
  550.             {
  551.                 _out = t;
  552.             }
  553.            
  554.             public override Encoding Encoding {
  555.                 get { return _out.Encoding; }
  556.             }
  557.            
  558.             public override IFormatProvider FormatProvider {
  559.                 get { return _out.FormatProvider; }
  560.             }
  561.            
  562.             public override string NewLine {
  563.                 [MethodImplAttribute(MethodImplOptions.Synchronized)]
  564.                 get { return _out.NewLine; }
  565.                 [MethodImplAttribute(MethodImplOptions.Synchronized)]
  566.                 set { _out.NewLine = value; }
  567.             }
  568.            
  569.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  570.             public override void Close()
  571.             {
  572.                 // So that any overriden Close() gets run
  573.                 _out.Close();
  574.             }
  575.            
  576.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  577.             protected override void Dispose(bool disposing)
  578.             {
  579.                 // Explicitly pick up a potentially methodimpl'ed Dispose
  580.                 if (disposing)
  581.                     ((IDisposable)_out).Dispose();
  582.             }
  583.            
  584.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  585.             public override void Flush()
  586.             {
  587.                 _out.Flush();
  588.             }
  589.            
  590.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  591.             public override void Write(char value)
  592.             {
  593.                 _out.Write(value);
  594.             }
  595.            
  596.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  597.             public override void Write(char[] buffer)
  598.             {
  599.                 _out.Write(buffer);
  600.             }
  601.            
  602.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  603.             public override void Write(char[] buffer, int index, int count)
  604.             {
  605.                 _out.Write(buffer, index, count);
  606.             }
  607.            
  608.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  609.             public override void Write(bool value)
  610.             {
  611.                 _out.Write(value);
  612.             }
  613.            
  614.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  615.             public override void Write(int value)
  616.             {
  617.                 _out.Write(value);
  618.             }
  619.            
  620.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  621.             public override void Write(uint value)
  622.             {
  623.                 _out.Write(value);
  624.             }
  625.            
  626.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  627.             public override void Write(long value)
  628.             {
  629.                 _out.Write(value);
  630.             }
  631.            
  632.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  633.             public override void Write(ulong value)
  634.             {
  635.                 _out.Write(value);
  636.             }
  637.            
  638.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  639.             public override void Write(float value)
  640.             {
  641.                 _out.Write(value);
  642.             }
  643.            
  644.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  645.             public override void Write(double value)
  646.             {
  647.                 _out.Write(value);
  648.             }
  649.            
  650.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  651.             public override void Write(decimal value)
  652.             {
  653.                 _out.Write(value);
  654.             }
  655.            
  656.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  657.             public override void Write(string value)
  658.             {
  659.                 _out.Write(value);
  660.             }
  661.            
  662.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  663.             public override void Write(object value)
  664.             {
  665.                 _out.Write(value);
  666.             }
  667.            
  668.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  669.             public override void Write(string format, object arg0)
  670.             {
  671.                 _out.Write(format, arg0);
  672.             }
  673.            
  674.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  675.             public override void Write(string format, object arg0, object arg1)
  676.             {
  677.                 _out.Write(format, arg0, arg1);
  678.             }
  679.            
  680.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  681.             public override void Write(string format, object arg0, object arg1, object arg2)
  682.             {
  683.                 _out.Write(format, arg0, arg1, arg2);
  684.             }
  685.            
  686.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  687.             public override void Write(string format, object[] arg)
  688.             {
  689.                 _out.Write(format, arg);
  690.             }
  691.            
  692.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  693.             public override void WriteLine()
  694.             {
  695.                 _out.WriteLine();
  696.             }
  697.            
  698.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  699.             public override void WriteLine(char value)
  700.             {
  701.                 _out.WriteLine(value);
  702.             }
  703.            
  704.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  705.             public override void WriteLine(decimal value)
  706.             {
  707.                 _out.WriteLine(value);
  708.             }
  709.            
  710.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  711.             public override void WriteLine(char[] buffer)
  712.             {
  713.                 _out.WriteLine(buffer);
  714.             }
  715.            
  716.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  717.             public override void WriteLine(char[] buffer, int index, int count)
  718.             {
  719.                 _out.WriteLine(buffer, index, count);
  720.             }
  721.            
  722.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  723.             public override void WriteLine(bool value)
  724.             {
  725.                 _out.WriteLine(value);
  726.             }
  727.            
  728.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  729.             public override void WriteLine(int value)
  730.             {
  731.                 _out.WriteLine(value);
  732.             }
  733.            
  734.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  735.             public override void WriteLine(uint value)
  736.             {
  737.                 _out.WriteLine(value);
  738.             }
  739.            
  740.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  741.             public override void WriteLine(long value)
  742.             {
  743.                 _out.WriteLine(value);
  744.             }
  745.            
  746.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  747.             public override void WriteLine(ulong value)
  748.             {
  749.                 _out.WriteLine(value);
  750.             }
  751.            
  752.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  753.             public override void WriteLine(float value)
  754.             {
  755.                 _out.WriteLine(value);
  756.             }
  757.            
  758.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  759.             public override void WriteLine(double value)
  760.             {
  761.                 _out.WriteLine(value);
  762.             }
  763.            
  764.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  765.             public override void WriteLine(string value)
  766.             {
  767.                 _out.WriteLine(value);
  768.             }
  769.            
  770.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  771.             public override void WriteLine(object value)
  772.             {
  773.                 _out.WriteLine(value);
  774.             }
  775.            
  776.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  777.             public override void WriteLine(string format, object arg0)
  778.             {
  779.                 _out.WriteLine(format, arg0);
  780.             }
  781.            
  782.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  783.             public override void WriteLine(string format, object arg0, object arg1)
  784.             {
  785.                 _out.WriteLine(format, arg0, arg1);
  786.             }
  787.            
  788.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  789.             public override void WriteLine(string format, object arg0, object arg1, object arg2)
  790.             {
  791.                 _out.WriteLine(format, arg0, arg1, arg2);
  792.             }
  793.            
  794.             [MethodImplAttribute(MethodImplOptions.Synchronized)]
  795.             public override void WriteLine(string format, object[] arg)
  796.             {
  797.                 _out.WriteLine(format, arg);
  798.             }
  799.         }
  800.     }
  801. }

Developer Fusion