dotnet
diff --git a/‎src/System.Console/src/System/IO/SyncTextReader.cs
Lines changed: 10 additions & 8 deletions b/‎src/System.Console/src/System/IO/SyncTextReader.cs
Lines changed: 10 additions & 8 deletions
diff --git a/‎src/System.Console/src/System/IO/SyncTextWriter.cs
Lines changed: 38 additions & 34 deletions b/‎src/System.Console/src/System/IO/SyncTextWriter.cs
Lines changed: 38 additions & 34 deletions
@@ -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();
             }
 
@@ -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);
             }
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,12 @@`
`8`	`8`
`9`	`9`	`namespace System.IO`
`10`	`10`	`{`
	`11`	`+ /* SyncTextReader intentionally locks on itself rather than a private lock object.`
	`12`	`+ * This is done to synchronize different console readers(Issue#2855).`
	`13`	`+ */`
`11`	`14`	`internal sealed class SyncTextReader : TextReader`
`12`	`15`	`{`
`13`	`16`	`private readonly TextReader _in;`
`14`		`- private readonly object _methodLock = new object();`
`15`	`17`
`16`	`18`	`public static SyncTextReader GetSynchronizedTextReader(TextReader reader)`
`17`	`19`	`{`
`@@ -29,7 +31,7 @@ protected override void Dispose(bool disposing)`
`29`	`31`	`{`
`30`	`32`	`if (disposing)`
`31`	`33`	`{`
`32`		`- lock (_methodLock)`
	`34`	`+ lock (this)`
`33`	`35`	`{`
`34`	`36`	`_in.Dispose();`
`35`	`37`	`}`
`@@ -38,47 +40,47 @@ protected override void Dispose(bool disposing)`
`38`	`40`
`39`	`41`	`public override int Peek()`
`40`	`42`	`{`
`41`		`- lock (_methodLock)`
	`43`	`+ lock (this)`
`42`	`44`	`{`
`43`	`45`	`return _in.Peek();`
`44`	`46`	`}`
`45`	`47`	`}`
`46`	`48`
`47`	`49`	`public override int Read()`
`48`	`50`	`{`
`49`		`- lock (_methodLock)`
	`51`	`+ lock (this)`
`50`	`52`	`{`
`51`	`53`	`return _in.Read();`
`52`	`54`	`}`
`53`	`55`	`}`
`54`	`56`
`55`	`57`	`public override int Read([In, Out] char[] buffer, int index, int count)`
`56`	`58`	`{`
`57`		`- lock (_methodLock)`
	`59`	`+ lock (this)`
`58`	`60`	`{`
`59`	`61`	`return _in.Read(buffer, index, count);`
`60`	`62`	`}`
`61`	`63`	`}`
`62`	`64`
`63`	`65`	`public override int ReadBlock([In, Out] char[] buffer, int index, int count)`
`64`	`66`	`{`
`65`		`- lock (_methodLock)`
	`67`	`+ lock (this)`
`66`	`68`	`{`
`67`	`69`	`return _in.ReadBlock(buffer, index, count);`
`68`	`70`	`}`
`69`	`71`	`}`
`70`	`72`
`71`	`73`	`public override String ReadLine()`
`72`	`74`	`{`
`73`		`- lock (_methodLock)`
	`75`	`+ lock (this)`
`74`	`76`	`{`
`75`	`77`	`return _in.ReadLine();`
`76`	`78`	`}`
`77`	`79`	`}`
`78`	`80`
`79`	`81`	`public override String ReadToEnd()`
`80`	`82`	`{`
`81`		`- lock (_methodLock)`
	`83`	`+ lock (this)`
`82`	`84`	`{`
`83`	`85`	`return _in.ReadToEnd();`
`84`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,13 @@`
`7`	`7`
`8`	`8`	`namespace System.IO`
`9`	`9`	`{`
	`10`	`+ /* SyncTextWriter intentionally locks on itself rather than a private lock object.`
	`11`	`+ * This is done to synchronize different console writers.`
	`12`	`+ * For example - colored console writers can be synchronized with non-colored`
	`13`	`+ * writers by locking on Console.On (Issue#2855).`
	`14`	`+ */`
`10`	`15`	`internal sealed class SyncTextWriter : TextWriter, IDisposable`
`11`	`16`	`{`
`12`		`- private readonly object _methodLock = new object();`
`13`	`17`	`internal readonly TextWriter _out;`
`14`	`18`
`15`	`19`	`internal static SyncTextWriter GetSynchronizedTextWriter(TextWriter writer)`
`@@ -37,15 +41,15 @@ public override IFormatProvider FormatProvider`
`37`	`41`
`38`	`42`	`public override String NewLine`
`39`	`43`	`{`
`40`		`- get { lock (_methodLock) { return _out.NewLine; } }`
`41`		`- set { lock (_methodLock) { _out.NewLine = value; } }`
	`44`	`+ get { lock (this) { return _out.NewLine; } }`
	`45`	`+ set { lock (this) { _out.NewLine = value; } }`
`42`	`46`	`}`
`43`	`47`
`44`	`48`	`protected override void Dispose(bool disposing)`
`45`	`49`	`{`
`46`	`50`	`if (disposing)`
`47`	`51`	`{`
`48`		`- lock (_methodLock)`
	`52`	`+ lock (this)`
`49`	`53`	`{`
`50`	`54`	`_out.Dispose();`
`51`	`55`	`}`
`@@ -54,239 +58,239 @@ protected override void Dispose(bool disposing)`
`54`	`58`
`55`	`59`	`public override void Flush()`
`56`	`60`	`{`
`57`		`- lock (_methodLock)`
	`61`	`+ lock (this)`
`58`	`62`	`{`
`59`	`63`	`_out.Flush();`
`60`	`64`	`}`
`61`	`65`	`}`
`62`	`66`
`63`	`67`	`public override void Write(char value)`
`64`	`68`	`{`
`65`		`- lock (_methodLock)`
	`69`	`+ lock (this)`
`66`	`70`	`{`
`67`	`71`	`_out.Write(value);`
`68`	`72`	`}`
`69`	`73`	`}`
`70`	`74`
`71`	`75`	`public override void Write(char[] buffer)`
`72`	`76`	`{`
`73`		`- lock (_methodLock)`
	`77`	`+ lock (this)`
`74`	`78`	`{`
`75`	`79`	`_out.Write(buffer);`
`76`	`80`	`}`
`77`	`81`	`}`
`78`	`82`
`79`	`83`	`public override void Write(char[] buffer, int index, int count)`
`80`	`84`	`{`
`81`		`- lock (_methodLock)`
	`85`	`+ lock (this)`
`82`	`86`	`{`
`83`	`87`	`_out.Write(buffer, index, count);`
`84`	`88`	`}`
`85`	`89`	`}`
`86`	`90`
`87`	`91`	`public override void Write(bool value)`
`88`	`92`	`{`
`89`		`- lock (_methodLock)`
	`93`	`+ lock (this)`
`90`	`94`	`{`
`91`	`95`	`_out.Write(value);`
`92`	`96`	`}`
`93`	`97`	`}`
`94`	`98`
`95`	`99`	`public override void Write(int value)`
`96`	`100`	`{`
`97`		`- lock (_methodLock)`
	`101`	`+ lock (this)`
`98`	`102`	`{`
`99`	`103`	`_out.Write(value);`
`100`	`104`	`}`
`101`	`105`	`}`
`102`	`106`
`103`	`107`	`public override void Write(uint value)`
`104`	`108`	`{`
`105`		`- lock (_methodLock)`
	`109`	`+ lock (this)`
`106`	`110`	`{`
`107`	`111`	`_out.Write(value);`
`108`	`112`	`}`
`109`	`113`	`}`
`110`	`114`
`111`	`115`	`public override void Write(long value)`
`112`	`116`	`{`
`113`		`- lock (_methodLock)`
	`117`	`+ lock (this)`
`114`	`118`	`{`
`115`	`119`	`_out.Write(value);`
`116`	`120`	`}`
`117`	`121`	`}`
`118`	`122`
`119`	`123`	`public override void Write(ulong value)`
`120`	`124`	`{`
`121`		`- lock (_methodLock)`
	`125`	`+ lock (this)`
`122`	`126`	`{`
`123`	`127`	`_out.Write(value);`
`124`	`128`	`}`
`125`	`129`	`}`
`126`	`130`
`127`	`131`	`public override void Write(float value)`
`128`	`132`	`{`
`129`		`- lock (_methodLock)`
	`133`	`+ lock (this)`
`130`	`134`	`{`
`131`	`135`	`_out.Write(value);`
`132`	`136`	`}`
`133`	`137`	`}`
`134`	`138`
`135`	`139`	`public override void Write(double value)`
`136`	`140`	`{`
`137`		`- lock (_methodLock)`
	`141`	`+ lock (this)`
`138`	`142`	`{`
`139`	`143`	`_out.Write(value);`
`140`	`144`	`}`
`141`	`145`	`}`
`142`	`146`
`143`	`147`	`public override void Write(Decimal value)`
`144`	`148`	`{`
`145`		`- lock (_methodLock)`
	`149`	`+ lock (this)`
`146`	`150`	`{`
`147`	`151`	`_out.Write(value);`
`148`	`152`	`}`
`149`	`153`	`}`
`150`	`154`
`151`	`155`	`public override void Write(String value)`
`152`	`156`	`{`
`153`		`- lock (_methodLock)`
	`157`	`+ lock (this)`
`154`	`158`	`{`
`155`	`159`	`_out.Write(value);`
`156`	`160`	`}`
`157`	`161`	`}`
`158`	`162`
`159`	`163`	`public override void Write(Object value)`
`160`	`164`	`{`
`161`		`- lock (_methodLock)`
	`165`	`+ lock (this)`
`162`	`166`	`{`
`163`	`167`	`_out.Write(value);`
`164`	`168`	`}`
`165`	`169`	`}`
`166`	`170`
`167`	`171`	`public override void Write(String format, Object[] arg)`
`168`	`172`	`{`
`169`		`- lock (_methodLock)`
	`173`	`+ lock (this)`
`170`	`174`	`{`
`171`	`175`	`_out.Write(format, arg);`
`172`	`176`	`}`
`173`	`177`	`}`
`174`	`178`
`175`	`179`	`public override void WriteLine()`
`176`	`180`	`{`
`177`		`- lock (_methodLock)`
	`181`	`+ lock (this)`
`178`	`182`	`{`
`179`	`183`	`_out.WriteLine();`
`180`	`184`	`}`
`181`	`185`	`}`
`182`	`186`
`183`	`187`	`public override void WriteLine(char value)`
`184`	`188`	`{`
`185`		`- lock (_methodLock)`
	`189`	`+ lock (this)`
`186`	`190`	`{`
`187`	`191`	`_out.WriteLine(value);`
`188`	`192`	`}`
`189`	`193`	`}`
`190`	`194`
`191`	`195`	`public override void WriteLine(decimal value)`
`192`	`196`	`{`
`193`		`- lock (_methodLock)`
	`197`	`+ lock (this)`
`194`	`198`	`{`
`195`	`199`	`_out.WriteLine(value);`
`196`	`200`	`}`
`197`	`201`	`}`
`198`	`202`
`199`	`203`	`public override void WriteLine(char[] buffer)`
`200`	`204`	`{`
`201`		`- lock (_methodLock)`
	`205`	`+ lock (this)`
`202`	`206`	`{`
`203`	`207`	`_out.WriteLine(buffer);`
`204`	`208`	`}`
`205`	`209`	`}`
`206`	`210`
`207`	`211`	`public override void WriteLine(char[] buffer, int index, int count)`
`208`	`212`	`{`
`209`		`- lock (_methodLock)`
	`213`	`+ lock (this)`
`210`	`214`	`{`
`211`	`215`	`_out.WriteLine(buffer, index, count);`
`212`	`216`	`}`
`213`	`217`	`}`
`214`	`218`
`215`	`219`	`public override void WriteLine(bool value)`
`216`	`220`	`{`
`217`		`- lock (_methodLock)`
	`221`	`+ lock (this)`
`218`	`222`	`{`
`219`	`223`	`_out.WriteLine(value);`
`220`	`224`	`}`
`221`	`225`	`}`
`222`	`226`
`223`	`227`	`public override void WriteLine(int value)`
`224`	`228`	`{`
`225`		`- lock (_methodLock)`
	`229`	`+ lock (this)`
`226`	`230`	`{`
`227`	`231`	`_out.WriteLine(value);`
`228`	`232`	`}`
`229`	`233`	`}`
`230`	`234`
`231`	`235`	`public override void WriteLine(uint value)`
`232`	`236`	`{`
`233`		`- lock (_methodLock)`
	`237`	`+ lock (this)`
`234`	`238`	`{`
`235`	`239`	`_out.WriteLine(value);`
`236`	`240`	`}`
`237`	`241`	`}`
`238`	`242`
`239`	`243`	`public override void WriteLine(long value)`
`240`	`244`	`{`
`241`		`- lock (_methodLock)`
	`245`	`+ lock (this)`
`242`	`246`	`{`
`243`	`247`	`_out.WriteLine(value);`
`244`	`248`	`}`
`245`	`249`	`}`
`246`	`250`
`247`	`251`	`public override void WriteLine(ulong value)`
`248`	`252`	`{`
`249`		`- lock (_methodLock)`
	`253`	`+ lock (this)`
`250`	`254`	`{`
`251`	`255`	`_out.WriteLine(value);`
`252`	`256`	`}`
`253`	`257`	`}`
`254`	`258`
`255`	`259`	`public override void WriteLine(float value)`
`256`	`260`	`{`
`257`		`- lock (_methodLock)`
	`261`	`+ lock (this)`
`258`	`262`	`{`
`259`	`263`	`_out.WriteLine(value);`
`260`	`264`	`}`
`261`	`265`	`}`
`262`	`266`
`263`	`267`	`public override void WriteLine(double value)`
`264`	`268`	`{`
`265`		`- lock (_methodLock)`
	`269`	`+ lock (this)`
`266`	`270`	`{`
`267`	`271`	`_out.WriteLine(value);`
`268`	`272`	`}`
`269`	`273`	`}`
`270`	`274`
`271`	`275`	`public override void WriteLine(String value)`
`272`	`276`	`{`
`273`		`- lock (_methodLock)`
	`277`	`+ lock (this)`
`274`	`278`	`{`
`275`	`279`	`_out.WriteLine(value);`
`276`	`280`	`}`
`277`	`281`	`}`
`278`	`282`
`279`	`283`	`public override void WriteLine(Object value)`
`280`	`284`	`{`
`281`		`- lock (_methodLock)`
	`285`	`+ lock (this)`
`282`	`286`	`{`
`283`	`287`	`_out.WriteLine(value);`
`284`	`288`	`}`
`285`	`289`	`}`
`286`	`290`
`287`	`291`	`public override void WriteLine(String format, Object[] arg)`
`288`	`292`	`{`
`289`		`- lock (_methodLock)`
	`293`	`+ lock (this)`
`290`	`294`	`{`
`291`	`295`	`_out.WriteLine(format, arg);`
`292`	`296`	`}`