Fix Issue#2808 : Support writing colored messages to console in a multi-threaded environment

In the System.Console portable library SyncTextReader/SyncTextWriter (the reader and writer used by the Console) locked on a private lock object
which prevented users from writing colored console messages in sync with non-colored writers. Note this behavior was a regression from the Desktop
where this could be achieved by locking against Console.Out which resulted in locking the writer APIs since the SyncTextWriter internally locked on itself.

Although this approach is formed via an implementation detail, however this sceanrio is useful and there exists no work-around for it in the portable library.
Hence, moving back to the earlier implementation, where the readers and writers locked against themselves instead of a private object.

Author: Pallavi Taneja

src/System.Console/src/System/IO/SyncTextReader.cs

@@ -8,10 +8,12 @@
 
 namespace System.IO
 {
+    /* SyncTextReader intentionally locks on itself rather than a private lock object.
+     * This is done to synchronize different console readers(Issue#2855).
+     */
     internal sealed class SyncTextReader : TextReader
     {
         private readonly TextReader _in;
-        private readonly object _methodLock = new object();
 
         public static SyncTextReader GetSynchronizedTextReader(TextReader reader)
         {
@@ -29,7 +31,7 @@ protected override void Dispose(bool disposing)
         {
             if (disposing)
             {
-                lock (_methodLock)
+                lock (this)
                 {
                     _in.Dispose();
                 }
@@ -38,47 +40,47 @@ protected override void Dispose(bool disposing)
 
         public override int Peek()
         {
-            lock (_methodLock)
+            lock (this)
             {
                 return _in.Peek();
             }
         }
 
         public override int Read()
         {
-            lock (_methodLock)
+            lock (this)
             {
                 return _in.Read();
             }
         }
 
         public override int Read([In, Out] char[] buffer, int index, int count)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 return _in.Read(buffer, index, count);
             }
         }
 
         public override int ReadBlock([In, Out] char[] buffer, int index, int count)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 return _in.ReadBlock(buffer, index, count);
             }
         }
 
         public override String ReadLine()
         {
-            lock (_methodLock)
+            lock (this)
             {
                 return _in.ReadLine();
             }
         }
 
         public override String ReadToEnd()
         {
-            lock (_methodLock)
+            lock (this)
             {
                 return _in.ReadToEnd();
             }

src/System.Console/src/System/IO/SyncTextWriter.cs

@@ -7,9 +7,13 @@
 
 namespace System.IO
 {
+    /* SyncTextWriter intentionally locks on itself rather than a private lock object.
+     * This is done to synchronize different console writers.
+     * For example - colored console writers can be synchronized with non-colored
+     * writers by locking on Console.On (Issue#2855).
+     */
     internal sealed class SyncTextWriter : TextWriter, IDisposable
     {
-        private readonly object _methodLock = new object();
         internal readonly TextWriter _out;
 
         internal static SyncTextWriter GetSynchronizedTextWriter(TextWriter writer)
@@ -37,15 +41,15 @@ public override IFormatProvider FormatProvider
 
         public override String NewLine
         {
-            get { lock (_methodLock) { return _out.NewLine; } }
-            set { lock (_methodLock) { _out.NewLine = value; } }
+            get { lock (this) { return _out.NewLine; } }
+            set { lock (this) { _out.NewLine = value; } }
         }
 
         protected override void Dispose(bool disposing)
         {
             if (disposing)
             {
-                lock (_methodLock)
+                lock (this)
                 {
                     _out.Dispose();
                 }
@@ -54,239 +58,239 @@ protected override void Dispose(bool disposing)
 
         public override void Flush()
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Flush();
             }
         }
 
         public override void Write(char value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(char[] buffer)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(buffer);
             }
         }
 
         public override void Write(char[] buffer, int index, int count)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(buffer, index, count);
             }
         }
 
         public override void Write(bool value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(int value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(uint value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(long value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(ulong value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(float value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(double value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(Decimal value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(String value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(Object value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(value);
             }
         }
 
         public override void Write(String format, Object[] arg)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.Write(format, arg);
             }
         }
 
         public override void WriteLine()
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine();
             }
         }
 
         public override void WriteLine(char value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(decimal value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(char[] buffer)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(buffer);
             }
         }
 
         public override void WriteLine(char[] buffer, int index, int count)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(buffer, index, count);
             }
         }
 
         public override void WriteLine(bool value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(int value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(uint value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(long value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(ulong value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(float value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(double value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(String value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(Object value)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(value);
             }
         }
 
         public override void WriteLine(String format, Object[] arg)
         {
-            lock (_methodLock)
+            lock (this)
             {
                 _out.WriteLine(format, arg);
             }