Console.WriteLine块吗？

Question

Console.WriteLine是否阻塞，直到输出被写入或立即返回？

如果有阻塞，是否有将异步输出写入控制台的方法？

Answer 1

不Console.WriteLine块，直到 输出已被写入或者它 立即返回？

是的。

如果是块是有的 写入异步输出到 控制台的方法？

如果您使用的是.NET 4.0，写入控制台而没有阻塞的解决方案出乎意料地微不足道。这个想法是排队文本值，并让一个专用线程执行Console.WriteLine调用。生产者 - 消费者模式在这里是理想的，因为它保留了在使用本地Console类时隐含的时间顺序。 .NET 4.0使这一切变得容易的原因是因为它具有促进生产者 - 消费者模式生产的类别BlockingCollection。如果你没有使用.NET 4.0，那么你可以通过下载Reactive Extensions框架来获得一个backport。

public static class NonBlockingConsole 
{ 
    private static BlockingCollection<string> m_Queue = new BlockingCollection<string>(); 

    static NonBlockingConsole() 
    { 
    var thread = new Thread(
    () => 
     { 
     while (true) Console.WriteLine(m_Queue.Take()); 
     }); 
    thread.IsBackground = true; 
    thread.Start(); 
    } 

    public static void WriteLine(string value) 
    { 
    m_Queue.Add(value); 
    } 
} 

Answer 2

是的，它阻止。我知道框架中没有内置的异步控制台写入。

Answer 3

在我办公桌上的快速测试表明，是的，它阻止。

要异步写入控制台，您可以将写入发送到另一个线程，然后写出它们。你可以通过让另一个线程旋转来实现，它有一个消息队列来写，或者通过链接Task实例来让你的写操作是有序的。

我之前的建议是使用线程池，因为它不能保证排序，因此，控制台输出可能会混淆。

Answer 4

是的，Console.WriteLine会阻塞，直到写入输出为止，因为它调用底层流实例的Write方法。您可以通过调用Console.OpenStandardOutput来获取流，然后在该流上调用BeginWrite和EndWrite来异步写入标准输出流（称为基础流）请注意，您必须执行自己的字符串编码（将System.String对象转换为字节[]），因为流只接受字节数组。

编辑 - 一些示例代码，您开始：

using System; 
using System.IO; 
using System.Text; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     string text = "Hello World!"; 

     Stream stdOut = Console.OpenStandardOutput(); 

     byte[] textAsBytes = Encoding.UTF8.GetBytes(text); 

     IAsyncResult result = stdOut.BeginWrite(textAsBytes, 0, textAsBytes.Length, callbackResult => stdOut.EndWrite(callbackResult), null); 

     Console.ReadLine(); 
    } 
} 

编辑2 - 另一种版本的基础上，布赖恩·基甸的意见建议（注意，这仅覆盖了十六个写&的WriteLine可用）的重载

实施开始/结束方法作为TextWriter类的扩展，然后添加一个AsyncConsole类打电话给他们：

using System; 
using System.IO; 
using System.Threading.Tasks; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     string text = "Hello World!"; 

     AsyncConsole.WriteLine(text); 

     Console.ReadLine(); 
    } 
} 

public static class TextWriterExtensions 
{ 
    public static IAsyncResult BeginWrite(this TextWriter writer, string value, AsyncCallback callback, object state) 
    { 
     return Task.Factory.StartNew(x => writer.Write(value), state).ContinueWith(new Action<Task>(callback)); 
    } 

    public static void EndWrite(this TextWriter writer, IAsyncResult result) 
    { 
     var task = result as Task; 

     task.Wait(); 
    } 

    public static IAsyncResult BeginWriteLine(this TextWriter writer, string value, AsyncCallback callback, object state) 
    { 
     return Task.Factory.StartNew(x => writer.WriteLine(value), state).ContinueWith(new Action<Task>(callback)); 
    } 

    public static void EndWriteLine(this TextWriter writer, IAsyncResult result) 
    { 
     var task = result as Task; 

     task.Wait(); 
    } 
} 

public static class AsyncConsole 
{ 
    public static IAsyncResult Write(string value) 
    { 
     return Console.Out.BeginWrite(value, callbackResult => Console.Out.EndWrite(callbackResult), null); 
    } 

    public static IAsyncResult WriteLine(string value) 
    { 
     return Console.Out.BeginWriteLine(value, callbackResult => Console.Out.EndWriteLine(callbackResult), null); 
    } 
} 

编辑3

或者，写一个异步的TextWriter，使用Console.SetOut注入它，然后调用Console.WriteLine 恰好为正常。

的TextWriter的会是这样的：

using System; 
using System.IO; 
using System.Text; 
using System.Threading.Tasks; 

public class AsyncStreamWriter 
    : TextWriter 
{ 
    private Stream stream; 
    private Encoding encoding; 

    public AsyncStreamWriter(Stream stream, Encoding encoding) 
    { 
     this.stream = stream; 
     this.encoding = encoding; 
    } 

    public override void Write(char[] value, int index, int count) 
    { 
     byte[] textAsBytes = this.Encoding.GetBytes(value, index, count); 

     Task.Factory.FromAsync(stream.BeginWrite, stream.EndWrite, textAsBytes, 0, textAsBytes.Length, null); 
    } 

    public override void Write(char value) 
    { 
     this.Write(new[] { value }); 
    } 

    public static void InjectAsConsoleOut() 
    { 
     Console.SetOut(new AsyncStreamWriter(Console.OpenStandardOutput(), Console.OutputEncoding)); 
    } 

    public override Encoding Encoding 
    { 
     get 
     { 
      return this.encoding; 
     } 
    } 
} 

请注意，我转向使用任务管理开始/结束的方法：这是因为BeginWrite方法本身似乎要禁止，如果已经有一个异步正在写入。

一旦你有了这个类，只需调用注射法和每呼叫您对Console.WriteLine，无论在哪里你把它或与超载，将成为异步的。 Comme ca：

class Program 
{ 
    static void Main(string[] args) 
    { 
     string text = "Hello World!"; 

     AsyncStreamWriter.InjectAsConsoleOut(); 

     Console.WriteLine(text); 

     Console.ReadLine(); 
    } 
} 

Answer 5

是的，它会阻塞，直到输出写入屏幕。我不确定这是否在文档中明确说明，但您可以通过在反射器中挖掘Console类来验证此情况。特别是InitializeStdOutError()方法。当为输出流创建TextWriter时，它将AutoFlush设置为true

Answer 6

Hmya，控制台输出不是特别快。但这是一个永远不需要修复的'问题'。关注奖品：为了人类的利益，您正在给控制台写信。那个人不能快速阅读。

如果输出重定向，它停止缓慢。如果这仍然对你的程序有影响，那么你可能只是写的方式太多的信息。改为写入文件。

Answer 7

随着.NET 4.5，TextWriter支持WriteAsync和WriteLineAsync方法，所以你现在可以使用：

Console.Out.WriteAsync("...");

和

Console.Out.WriteLineAsync("...");