X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2Fcorlib%2FSystem.IO%2FTextWriter.cs;h=ad3906fe2b44c15cb6f155476c6c3148ed48a3ec;hb=b52c963187c59fd167cfde556dfd4304f8ded041;hp=7ba815aa1ece3425fb1cffc2cb68a333a38d9685;hpb=0d5fadd9d04031184a65c4dec5da5476ea66b086;p=mono.git

diff --git a/mcs/class/corlib/System.IO/TextWriter.cs b/mcs/class/corlib/System.IO/TextWriter.cs
index 7ba815aa1ec..ad3906fe2b4 100644
--- a/mcs/class/corlib/System.IO/TextWriter.cs
+++ b/mcs/class/corlib/System.IO/TextWriter.cs
@@ -1,651 +1,809 @@
-//
-// System.IO.TextWriter
-//
-// Authors:
-//   Marcin Szczepanski (marcins@zipworld.com.au)
-//   Miguel de Icaza (miguel@gnome.org)
-//   Paolo Molaro (lupus@ximian.com)
-//
-
-//
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-// 
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Text;
-
-namespace System.IO {
-
-	[Serializable]
-	public abstract class TextWriter : MarshalByRefObject, IDisposable {
-                
-                protected TextWriter() {
-			CoreNewLine = System.Environment.NewLine.ToCharArray ();
-		}
-                
-                protected TextWriter( IFormatProvider formatProvider ) {
-                        internalFormatProvider = formatProvider;
-                }
-
-                protected char[] CoreNewLine;
-
-                internal IFormatProvider internalFormatProvider;
-
-                public static readonly TextWriter Null = new NullTextWriter ();
-
-                public abstract Encoding Encoding { get; }
-
-                public virtual IFormatProvider FormatProvider { 
-                        get {
-                                return internalFormatProvider;
-                        } 
-                }
-
-                public virtual string NewLine { 
-                        get {
-                                return new string(CoreNewLine);
-                        }
-                        
-                        set {
-				if (value == null)
-					value = Environment.NewLine;
-
-				CoreNewLine = value.ToCharArray();
-                        }
-                }
-
-                public virtual void Close () { 
-                        Dispose (true);
-                }
-
-                protected virtual void Dispose (bool disposing) { }
-                
-		void System.IDisposable.Dispose () {
-			Dispose (true);
-		}
-
-
-                public virtual void Flush()
-		{
-			// do nothing
-		}
-
-                public static TextWriter Synchronized (TextWriter writer)
-		{
-			return Synchronized (writer, false);
-                }
-
-                internal static TextWriter Synchronized (TextWriter writer, bool neverClose)
-		{
-			if (writer == null)
-				throw new ArgumentNullException ("writer is null");
-
-			if (writer is SynchronizedWriter)
-				return writer;
-			
-			return new SynchronizedWriter (writer, neverClose);
-                }
-
-                public virtual void Write (bool value)
-		{
-			Write (value.ToString ());
-		}
-		
-                public virtual void Write (char value)
-		{
-			// Do nothing
-		}
-
-                public virtual void Write (char[] value)
-		{
-			if (value != null) {
-				for (int i = 0; i < value.Length; ++i)
-					Write (value [i]);
-			}
-		}
-		
-                public virtual void Write (decimal value)
-		{
-			Write (value.ToString (internalFormatProvider));
-		}
-		
-                public virtual void Write (double value)
-		{
-			Write (value.ToString (internalFormatProvider));
-		}
-
-                public virtual void Write (int value)
-		{
-			Write (value.ToString (internalFormatProvider));
-		}
-		
-                public virtual void Write (long value)
-		{
-			Write (value.ToString (internalFormatProvider));
-		}
-		
-                public virtual void Write (object value)
-		{
-			if (value != null)
-				Write (value.ToString ());
-		}
-		
-                public virtual void Write (float value)
-		{
-			Write (value.ToString (internalFormatProvider));
-		}
-		
-                public virtual void Write (string value)
-		{
-			if (value != null)
-				Write (value.ToCharArray ());
-		}
-		
-		[CLSCompliant(false)]
-                public virtual void Write (uint value)
-		{
-			Write (value.ToString (internalFormatProvider));
-		}
-		
-		[CLSCompliant(false)]
-                public virtual void Write (ulong value)
-		{
-			Write (value.ToString (internalFormatProvider));
-		}
-		
-                public virtual void Write (string format, object arg0)
-		{
-			Write (String.Format (format, arg0));
-		}
-		
-                public virtual void Write (string format, params object[] arg)
-		{
-			Write (String.Format (format, arg));
-		}
-		
-                public virtual void Write (char[] buffer, int index, int count)
-		{
-			if (buffer == null)
-				throw new ArgumentNullException ("buffer");
-			if (index < 0 || index > buffer.Length)
-				throw new ArgumentOutOfRangeException ("index");
-			// re-ordered to avoid possible integer overflow
-			if (count < 0 || (index > buffer.Length - count))
-				throw new ArgumentOutOfRangeException ("count");
-
-			for (; count > 0; --count, ++index) {
-				Write (buffer [index]);
-			}
-		}
-		
-                public virtual void Write (string format, object arg0, object arg1)
-		{
-			Write (String.Format (format, arg0, arg1));
-		}
-		
-                public virtual void Write (string format, object arg0, object arg1, object arg2 )
-		{
-			Write (String.Format (format, arg0, arg1, arg2));
-		}
-                
-                public virtual void WriteLine ()
-		{
-			Write (NewLine);
-		}
-		
-                public virtual void WriteLine (bool value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (char value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (char[] value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (decimal value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (double value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (int value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (long value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (object value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (float value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (string value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-		[CLSCompliant(false)]
-                public virtual void WriteLine (uint value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-		[CLSCompliant(false)]
-                public virtual void WriteLine (ulong value)
-		{
-			Write (value);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (string format, object arg0)
-		{
-			Write (format, arg0);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (string format, params object[] arg)
-		{
-			Write (format, arg);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (char[] buffer, int index, int count)
-		{
-			Write (buffer, index, count);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (string format, object arg0, object arg1)
-		{
-			Write (format, arg0, arg1);
-			WriteLine();
-		}
-		
-                public virtual void WriteLine (string format, object arg0, object arg1, object arg2)
-		{
-			Write (format, arg0, arg1, arg2);
-			WriteLine();
-		}
-
-		//
-		// Null version of the TextWriter, for the `Null' instance variable
-		//
-		sealed class NullTextWriter : TextWriter {
-			public override Encoding Encoding {
-				get {
-					return Encoding.Default;
-				}
-			}
-			
-			public override void Write (string s)
-			{
-			}
-			public override void Write (char value)
-			{
-			}
-			public override void Write (char[] value, int index, int count)
-			{
-			}
-		}
-        }
-
-	//
-	// Sychronized version of the TextWriter.
-	//
-	[Serializable]
-	internal class SynchronizedWriter : TextWriter {
-		private TextWriter writer;
-		private bool neverClose;
-
-		public SynchronizedWriter (TextWriter writer)
-			: this (writer, false)
-		{
-		}
-
-		public SynchronizedWriter (TextWriter writer, bool neverClose)
-		{
-			this.writer = writer;
-			this.neverClose = neverClose;
-		}
-
-		public override void Close ()
-		{
-			if (neverClose)
-				return;
-			lock (this){
-				writer.Close ();
-			}
-		}
-
-		public override void Flush ()
-		{
-			lock (this){
-				writer.Flush ();
-			}
-		}
-
-#region Write methods
-		public override void Write (bool value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-		
-		public override void Write (char value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-
-		public override void Write (char [] value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-
-		public override void Write (Decimal value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-
-		public override void Write (int value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-
-		public override void Write (long value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-		
-		public override void Write (object value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-
-		public override void Write (float value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-		
-		public override void Write (string value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-		
-		public override void Write (uint value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-		
-		public override void Write (ulong value)
-		{
-			lock (this){
-				writer.Write (value);
-			}
-		}
-		
-		public override void Write (string format, object value)
-		{
-			lock (this){
-				writer.Write (format, value);
-			}
-		}
-		
-		public override void Write (string format, object [] value)
-		{
-			lock (this){
-				writer.Write (format, value);
-			}
-		}
-
-		public override void Write (char [] buffer, int index, int count)
-		{
-			lock (this){
-				writer.Write (buffer, index, count);
-			}
-		}
-		
-		public override void Write (string format, object arg0, object arg1)
-		{
-			lock (this){
-				writer.Write (format, arg0, arg1);
-			}
-		}
-		
-		public override void Write (string format, object arg0, object arg1, object arg2)
-		{
-			lock (this){
-				writer.Write (format, arg0, arg1, arg2);
-			}
-		}
-#endregion
-#region WriteLine methods
-		public override void WriteLine ()
-		{
-			lock (this){
-				writer.WriteLine ();
-			}
-		}
-
-		public override void WriteLine (bool value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (char value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (char [] value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (Decimal value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (double value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (int value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (long value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (object value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (float value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (string value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (uint value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (ulong value)
-		{
-			lock (this){
-				writer.WriteLine (value);
-			}
-		}
-
-		public override void WriteLine (string format, object value)
-		{
-			lock (this){
-				writer.WriteLine (format, value);
-			}
-		}
-
-		public override void WriteLine (string format, object [] value)
-		{
-			lock (this){
-				writer.WriteLine (format, value);
-			}
-		}
-
-		public override void WriteLine (char [] buffer, int index, int count)
-		{
-			lock (this){
-				writer.WriteLine (buffer, index, count);
-			}
-		}
-		
-		public override void WriteLine (string format, object arg0, object arg1)
-		{
-			lock (this){
-				writer.WriteLine (format, arg0, arg1);
-			}
-		}
-
-		public override void WriteLine (string format, object arg0, object arg1, object arg2)
-		{
-			lock (this){
-				writer.WriteLine (format, arg0, arg1, arg2);
-			}
-		}
-#endregion
-		
-		public override Encoding Encoding {
-			get {
-				lock (this){
-					return writer.Encoding;
-				}
-			}
-		}
-
-		public override IFormatProvider FormatProvider {
-			get {
-				lock (this){
-					return writer.FormatProvider;
-				}
-			}
-		}
-
-		public override string NewLine {
-			get {
-				lock (this){
-					return writer.NewLine;
-				}
-			}
-
-			set {
-				lock (this){
-					writer.NewLine = value;
-				}
-			}
-		}
-	}
-}
-
-
-
-
-
+//
+// System.IO.TextWriter.cs
+//
+// Authors:
+//   Marcin Szczepanski (marcins@zipworld.com.au)
+//   Miguel de Icaza (miguel@gnome.org)
+//   Paolo Molaro (lupus@ximian.com)
+//   Marek Safar (marek.safar@gmail.com)
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+// Copyright 2011 Xamarin Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System.Text;
+using System.Runtime.InteropServices;
+#if NET_4_5
+using System.Threading.Tasks;
+#endif
+
+namespace System.IO
+{
+
+	[Serializable]
+	[ComVisible (true)]
+#if NET_2_1
+	public abstract class TextWriter : IDisposable {
+#else
+	public abstract class TextWriter : MarshalByRefObject, IDisposable
+	{
+#endif
+		//
+		// Null version of the TextWriter, for the `Null' instance variable
+		//
+		sealed class NullTextWriter : TextWriter
+		{
+			public override Encoding Encoding
+			{
+				get
+				{
+					return Encoding.Default;
+				}
+			}
+
+			public override void Write (string s)
+			{
+			}
+			public override void Write (char value)
+			{
+			}
+			public override void Write (char[] value, int index, int count)
+			{
+			}
+		}
+
+		protected TextWriter ()
+		{
+			CoreNewLine = System.Environment.NewLine.ToCharArray ();
+		}
+
+		protected TextWriter (IFormatProvider formatProvider)
+		{
+			CoreNewLine = System.Environment.NewLine.ToCharArray ();
+			internalFormatProvider = formatProvider;
+		}
+
+		protected char[] CoreNewLine;
+
+		internal IFormatProvider internalFormatProvider;
+
+		public static readonly TextWriter Null = new NullTextWriter ();
+
+		public abstract Encoding Encoding { get; }
+
+		public virtual IFormatProvider FormatProvider {
+			get {
+				return internalFormatProvider;
+			}
+		}
+
+		public virtual string NewLine {
+			get {
+				return new string (CoreNewLine);
+			}
+
+			set {
+				if (value == null)
+					value = Environment.NewLine;
+
+				CoreNewLine = value.ToCharArray ();
+			}
+		}
+
+		public virtual void Close ()
+		{
+			Dispose (true);
+		}
+
+		protected virtual void Dispose (bool disposing)
+		{
+			if (disposing) {
+				// If we are explicitly disposed, we can avoid finalization.
+				GC.SuppressFinalize (this);
+			}
+		}
+		public void Dispose ()
+		{
+			Dispose (true);
+
+			// If we are explicitly disposed, we can avoid finalization.
+			GC.SuppressFinalize (this);
+		}
+
+		public virtual void Flush ()
+		{
+			// do nothing
+		}
+
+		public static TextWriter Synchronized (TextWriter writer)
+		{
+			return Synchronized (writer, false);
+		}
+
+		internal static TextWriter Synchronized (TextWriter writer, bool neverClose)
+		{
+			if (writer == null)
+				throw new ArgumentNullException ("writer is null");
+
+			if (writer is SynchronizedWriter)
+				return writer;
+
+			return new SynchronizedWriter (writer, neverClose);
+		}
+
+		public virtual void Write (bool value)
+		{
+			Write (value.ToString ());
+		}
+
+		public virtual void Write (char value)
+		{
+			// Do nothing
+		}
+
+		public virtual void Write (char[] buffer)
+		{
+			if (buffer == null)
+				return;
+			Write (buffer, 0, buffer.Length);
+		}
+
+		public virtual void Write (decimal value)
+		{
+			Write (value.ToString (internalFormatProvider));
+		}
+
+		public virtual void Write (double value)
+		{
+			Write (value.ToString (internalFormatProvider));
+		}
+
+		public virtual void Write (int value)
+		{
+			Write (value.ToString (internalFormatProvider));
+		}
+
+		public virtual void Write (long value)
+		{
+			Write (value.ToString (internalFormatProvider));
+		}
+
+		public virtual void Write (object value)
+		{
+			if (value != null)
+				Write (value.ToString ());
+		}
+
+		public virtual void Write (float value)
+		{
+			Write (value.ToString (internalFormatProvider));
+		}
+
+		public virtual void Write (string value)
+		{
+			if (value != null)
+				Write (value.ToCharArray ());
+		}
+
+		[CLSCompliant (false)]
+		public virtual void Write (uint value)
+		{
+			Write (value.ToString (internalFormatProvider));
+		}
+
+		[CLSCompliant (false)]
+		public virtual void Write (ulong value)
+		{
+			Write (value.ToString (internalFormatProvider));
+		}
+
+		public virtual void Write (string format, object arg0)
+		{
+			Write (String.Format (format, arg0));
+		}
+
+		public virtual void Write (string format, params object[] arg)
+		{
+			Write (String.Format (format, arg));
+		}
+
+		public virtual void Write (char[] buffer, int index, int count)
+		{
+			if (buffer == null)
+				throw new ArgumentNullException ("buffer");
+			if (index < 0 || index > buffer.Length)
+				throw new ArgumentOutOfRangeException ("index");
+			// re-ordered to avoid possible integer overflow
+			if (count < 0 || (index > buffer.Length - count))
+				throw new ArgumentOutOfRangeException ("count");
+
+			for (; count > 0; --count, ++index) {
+				Write (buffer[index]);
+			}
+		}
+
+		public virtual void Write (string format, object arg0, object arg1)
+		{
+			Write (String.Format (format, arg0, arg1));
+		}
+
+		public virtual void Write (string format, object arg0, object arg1, object arg2)
+		{
+			Write (String.Format (format, arg0, arg1, arg2));
+		}
+
+		public virtual void WriteLine ()
+		{
+			Write (CoreNewLine);
+		}
+
+		public virtual void WriteLine (bool value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (char value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (char[] buffer)
+		{
+			Write (buffer);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (decimal value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (double value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (int value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (long value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (object value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (float value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (string value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		[CLSCompliant (false)]
+		public virtual void WriteLine (uint value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		[CLSCompliant (false)]
+		public virtual void WriteLine (ulong value)
+		{
+			Write (value);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (string format, object arg0)
+		{
+			Write (format, arg0);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (string format, params object[] arg)
+		{
+			Write (format, arg);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (char[] buffer, int index, int count)
+		{
+			Write (buffer, index, count);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (string format, object arg0, object arg1)
+		{
+			Write (format, arg0, arg1);
+			WriteLine ();
+		}
+
+		public virtual void WriteLine (string format, object arg0, object arg1, object arg2)
+		{
+			Write (format, arg0, arg1, arg2);
+			WriteLine ();
+		}
+
+#if NET_4_5
+		public virtual Task FlushAsync ()
+		{
+			return Task.Factory.StartNew (l => ((TextWriter)l).Flush (), this);
+		}
+
+		//
+		// Use tuple to pack the arguments because it's faster than
+		// setting up anonymous method container with an instance delegate
+		//
+		public virtual Task WriteAsync (char value)
+		{
+			return Task.Factory.StartNew (l => {
+				var t = (Tuple<TextWriter, char>) l;
+				t.Item1.Write (t.Item2);
+			}, Tuple.Create (this, value));
+		}
+
+		public Task WriteAsync (char[] buffer)
+		{
+			if (buffer == null)
+				return TaskConstants.Finished;
+
+			return WriteAsync (buffer, 0, buffer.Length);
+		}
+
+		public virtual Task WriteAsync (char[] buffer, int index, int count)
+		{
+			return Task.Factory.StartNew (l => {
+				var t = (Tuple<TextWriter, char[], int, int>) l;
+				t.Item1.Write (t.Item2, t.Item3, t.Item4);
+			}, Tuple.Create (this, buffer, index, count));
+		}
+
+		public virtual Task WriteAsync (string value)
+		{
+			return Task.Factory.StartNew (l => {
+				var t = (Tuple<TextWriter, string>) l;
+				t.Item1.Write (t.Item2);
+			}, Tuple.Create (this, value));
+		}
+
+		public virtual Task WriteLineAsync ()
+		{
+			return WriteAsync (CoreNewLine);
+		}
+
+		public virtual Task WriteLineAsync (char value)
+		{
+			return Task.Factory.StartNew (l => {
+				var t = (Tuple<TextWriter, char>) l;
+				t.Item1.WriteLine (t.Item2);
+			}, Tuple.Create (this, value));
+		}
+
+		public Task WriteLineAsync (char[] buffer)
+		{
+			return Task.Factory.StartNew (l => {
+				var t = (Tuple<TextWriter, char[]>) l;
+				t.Item1.WriteLine (t.Item2);
+			}, Tuple.Create (this, buffer));
+		}
+
+		public virtual Task WriteLineAsync (char[] buffer, int index, int count)
+		{
+			return Task.Factory.StartNew (l => {
+				var t = (Tuple<TextWriter, char[], int, int>) l;
+				t.Item1.WriteLine (t.Item2, t.Item3, t.Item4);
+			}, Tuple.Create (this, buffer, index, count));
+		}
+
+		public virtual Task WriteLineAsync (string value)
+		{
+			return Task.Factory.StartNew (l => {
+				var t = (Tuple<TextWriter, string>) l;
+				t.Item1.WriteLine (t.Item2);
+			}, Tuple.Create (this, value));
+		}
+#endif
+	}
+
+	//
+	// Sychronized version of the TextWriter.
+	//
+	[Serializable]
+	sealed class SynchronizedWriter : TextWriter
+	{
+		private TextWriter writer;
+		private bool neverClose;
+
+		public SynchronizedWriter (TextWriter writer)
+			: this (writer, false)
+		{
+		}
+
+		public SynchronizedWriter (TextWriter writer, bool neverClose)
+		{
+			this.writer = writer;
+			this.neverClose = neverClose;
+		}
+
+		public override void Close ()
+		{
+			if (neverClose)
+				return;
+			lock (this) {
+				writer.Close ();
+			}
+		}
+
+		public override void Flush ()
+		{
+			lock (this) {
+				writer.Flush ();
+			}
+		}
+
+		#region Write methods
+		public override void Write (bool value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (char value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (char[] value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (Decimal value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (int value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (long value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (object value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (float value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (string value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (uint value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (ulong value)
+		{
+			lock (this) {
+				writer.Write (value);
+			}
+		}
+
+		public override void Write (string format, object value)
+		{
+			lock (this) {
+				writer.Write (format, value);
+			}
+		}
+
+		public override void Write (string format, object[] value)
+		{
+			lock (this) {
+				writer.Write (format, value);
+			}
+		}
+
+		public override void Write (char[] buffer, int index, int count)
+		{
+			lock (this) {
+				writer.Write (buffer, index, count);
+			}
+		}
+
+		public override void Write (string format, object arg0, object arg1)
+		{
+			lock (this) {
+				writer.Write (format, arg0, arg1);
+			}
+		}
+
+		public override void Write (string format, object arg0, object arg1, object arg2)
+		{
+			lock (this) {
+				writer.Write (format, arg0, arg1, arg2);
+			}
+		}
+		#endregion
+		#region WriteLine methods
+		public override void WriteLine ()
+		{
+			lock (this) {
+				writer.WriteLine ();
+			}
+		}
+
+		public override void WriteLine (bool value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (char value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (char[] value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (Decimal value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (double value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (int value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (long value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (object value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (float value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (string value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (uint value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (ulong value)
+		{
+			lock (this) {
+				writer.WriteLine (value);
+			}
+		}
+
+		public override void WriteLine (string format, object value)
+		{
+			lock (this) {
+				writer.WriteLine (format, value);
+			}
+		}
+
+		public override void WriteLine (string format, object[] value)
+		{
+			lock (this) {
+				writer.WriteLine (format, value);
+			}
+		}
+
+		public override void WriteLine (char[] buffer, int index, int count)
+		{
+			lock (this) {
+				writer.WriteLine (buffer, index, count);
+			}
+		}
+
+		public override void WriteLine (string format, object arg0, object arg1)
+		{
+			lock (this) {
+				writer.WriteLine (format, arg0, arg1);
+			}
+		}
+
+		public override void WriteLine (string format, object arg0, object arg1, object arg2)
+		{
+			lock (this) {
+				writer.WriteLine (format, arg0, arg1, arg2);
+			}
+		}
+		#endregion
+
+#if NET_4_5
+		public override Task FlushAsync ()
+		{
+			lock (this) {
+				return writer.FlushAsync ();
+			}
+		}
+
+		public override Task WriteAsync (char value)
+		{
+			lock (this) {
+				return writer.WriteAsync (value);
+			}
+		}
+
+		public override Task WriteAsync (char[] buffer, int index, int count)
+		{
+			lock (this) {
+				return writer.WriteAsync (buffer, index, count);
+			}
+		}
+
+		public override Task WriteAsync (string value)
+		{
+			lock (this) {
+				return writer.WriteAsync (value);
+			}
+		}
+
+		public override Task WriteLineAsync ()
+		{
+			lock (this) {
+				return writer.WriteLineAsync ();
+			}
+		}
+
+		public override Task WriteLineAsync (char value)
+		{
+			lock (this) {
+				return writer.WriteLineAsync (value);
+			}
+		}
+
+		public override Task WriteLineAsync (char[] buffer, int index, int count)
+		{
+			lock (this) {
+				return writer.WriteLineAsync (buffer, index, count);
+			}
+		}
+
+		public override Task WriteLineAsync (string value)
+		{
+			lock (this) {
+				return writer.WriteLineAsync (value);
+			}
+		}
+#endif
+		public override Encoding Encoding {
+			get {
+				lock (this) {
+					return writer.Encoding;
+				}
+			}
+		}
+
+		public override IFormatProvider FormatProvider {
+			get {
+				lock (this) {
+					return writer.FormatProvider;
+				}
+			}
+		}
+
+		public override string NewLine {
+			get {
+				lock (this) {
+					return writer.NewLine;
+				}
+			}
+
+			set {
+				lock (this) {
+					writer.NewLine = value;
+				}
+			}
+		}
+	}
+}