如何向 Console.ReadLine() 添加超时？
https://stackoverflow.com/questions/57615
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
我有一个控制台应用程序，我想在其中向用户提供 X 秒响应提示。如果一段时间后没有输入，程序逻辑应该继续。我们假设超时意味着空响应。
解决这个问题最直接的方法是什么？
解决方案
我惊讶地发现，5 年后，所有答案仍然存在以下一个或多个问题：
- 使用了 ReadLine 以外的函数，导致功能丧失。（删除/退格/向上键用于先前的输入）。
- 多次调用时，函数会表现得很糟糕（产生多个线程、许多挂起的 ReadLine 或其他意外行为）。
- 功能依赖于忙等待。这是一种可怕的浪费，因为等待预计会持续几秒到超时，这可能是几分钟。运行如此长的时间的忙等待会消耗大量资源，这在多线程场景中尤其糟糕。如果用睡眠修改忙等待，这会对响应能力产生负面影响，尽管我承认这可能不是一个大问题。
我相信我的解决方案将解决原来的问题，而不会遇到上述任何问题：
class Reader {
private static Thread inputThread;
private static AutoResetEvent getInput, gotInput;
private static string input;
static Reader() {
getInput = new AutoResetEvent(false);
gotInput = new AutoResetEvent(false);
inputThread = new Thread(reader);
inputThread.IsBackground = true;
inputThread.Start();
}
private static void reader() {
while (true) {
getInput.WaitOne();
input = Console.ReadLine();
gotInput.Set();
}
}
// omit the parameter to read a line without a timeout
public static string ReadLine(int timeOutMillisecs = Timeout.Infinite) {
getInput.Set();
bool success = gotInput.WaitOne(timeOutMillisecs);
if (success)
return input;
else
throw new TimeoutException("User did not provide input within the timelimit.");
}
}
当然，调用非常简单：
try {
Console.WriteLine("Please enter your name within the next 5 seconds.");
string name = Reader.ReadLine(5000);
Console.WriteLine("Hello, {0}!", name);
} catch (TimeoutException) {
Console.WriteLine("Sorry, you waited too long.");
}
或者，您可以使用 TryXX(out) 正如 shmueli 建议的那样：
public static bool TryReadLine(out string line, int timeOutMillisecs = Timeout.Infinite) {
getInput.Set();
bool success = gotInput.WaitOne(timeOutMillisecs);
if (success)
line = input;
else
line = null;
return success;
}
其调用方式如下：
Console.WriteLine("Please enter your name within the next 5 seconds.");
string name;
bool success = Reader.TryReadLine(out name, 5000);
if (!success)
Console.WriteLine("Sorry, you waited too long.");
else
Console.WriteLine("Hello, {0}!", name);
在这两种情况下，您不能混合调用 Reader 与正常的 Console.ReadLine 呼叫：如果 Reader 超时，就会出现挂起 ReadLine 称呼。相反，如果你想有一个正常的（非定时的） ReadLine 调用，只需使用 Reader 并省略超时，使其默认为无限超时。
那么我提到的其他解决方案的那些问题又如何呢？
- 可以看到，使用了ReadLine，避免了第一个问题。
- 该函数在多次调用时表现正常。无论是否发生超时，都只会运行一个后台线程，并且最多只会有一个对 ReadLine 的调用处于活动状态。调用该函数将始终导致最新输入或超时，并且用户不必多次按 Enter 键即可提交输入。
- 而且，显然，该函数不依赖于忙等待。相反，它使用适当的多线程技术来防止浪费资源。
我预见到这个解决方案的唯一问题是它不是线程安全的。但是，多个线程实际上无法同时请求用户输入，因此应该在调用之前进行同步 Reader.ReadLine 反正。
其他提示
string ReadLine(int timeoutms)
{
ReadLineDelegate d = Console.ReadLine;
IAsyncResult result = d.BeginInvoke(null, null);
result.AsyncWaitHandle.WaitOne(timeoutms);//timeout e.g. 15000 for 15 secs
if (result.IsCompleted)
{
string resultstr = d.EndInvoke(result);
Console.WriteLine("Read: " + resultstr);
return resultstr;
}
else
{
Console.WriteLine("Timed out!");
throw new TimedoutException("Timed Out!");
}
}
delegate string ReadLineDelegate();
这种方法会使用 Console.KeyAvailable 帮助？
class Sample
{
public static void Main()
{
ConsoleKeyInfo cki = new ConsoleKeyInfo();
do {
Console.WriteLine("\nPress a key to display; press the 'x' key to quit.");
// Your code could perform some useful task in the following loop. However,
// for the sake of this example we'll merely pause for a quarter second.
while (Console.KeyAvailable == false)
Thread.Sleep(250); // Loop until input is entered.
cki = Console.ReadKey(true);
Console.WriteLine("You pressed the '{0}' key.", cki.Key);
} while(cki.Key != ConsoleKey.X);
}
}
不管怎样，你确实需要第二个线程。您可以使用异步 IO 来避免声明您自己的：
- 声明一个 ManualResetEvent，将其命名为“evt”
- 调用 System.Console.OpenStandardInput 获取输入流。指定一个回调方法来存储其数据并设置 evt。
- 调用该流的 BeginRead 方法来启动异步读取操作
- 然后在 ManualResetEvent 上输入定时等待
- 如果等待超时，则取消读取
如果读取返回数据，则设置事件，主线程将继续，否则超时后将继续。
// Wait for 'Enter' to be pressed or 5 seconds to elapse
using (Stream s = Console.OpenStandardInput())
{
ManualResetEvent stop_waiting = new ManualResetEvent(false);
s.BeginRead(new Byte[1], 0, 1, ar => stop_waiting.Set(), null);
// ...do anything else, or simply...
stop_waiting.WaitOne(5000);
// If desired, other threads could also set 'stop_waiting'
// Disposing the stream cancels the async read operation. It can be
// re-opened if needed.
}
这对我有用。
ConsoleKeyInfo k = new ConsoleKeyInfo();
Console.WriteLine("Press any key in the next 5 seconds.");
for (int cnt = 5; cnt > 0; cnt--)
{
if (Console.KeyAvailable == true)
{
k = Console.ReadKey();
break;
}
else
{
Console.WriteLine(cnt.ToString());
System.Threading.Thread.Sleep(1000);
}
}
Console.WriteLine("The key pressed was " + k.Key);
我认为您需要创建一个辅助线程并轮询控制台上的键。我知道没有内置方法可以实现此目的。
我为这个问题苦苦挣扎了 5 个月，才找到了一个在企业环境中完美运行的解决方案。
到目前为止，大多数解决方案的问题在于它们依赖于 Console.ReadLine() 之外的其他东西，而 Console.ReadLine() 有很多优点：
- 支持删除、退格键、方向键等。
- 能够按“向上”键并重复最后一个命令（如果您实现经常使用的后台调试控制台，这会非常方便）。
我的解决方案如下：
- 产生一个 单独的线程 使用 Console.ReadLine() 处理用户输入。
- 超时后，通过将 [enter] 键发送到当前控制台窗口来取消阻止 Console.ReadLine()，使用 http://inputsimulator.codeplex.com/.
示例代码：
InputSimulator.SimulateKeyPress(VirtualKeyCode.RETURN);
有关此技术的更多信息，包括中止使用 Console.ReadLine 的线程的正确技术：
在委托中调用 Console.ReadLine() 是不好的，因为如果用户没有按“enter”键，那么该调用将永远不会返回。执行委托的线程将被阻塞，直到用户点击“enter”，并且无法取消它。
发出一系列这些调用将不会按照您的预期运行。考虑以下内容（使用上面的示例 Console 类）：
System.Console.WriteLine("Enter your first name [John]:");
string firstName = Console.ReadLine(5, "John");
System.Console.WriteLine("Enter your last name [Doe]:");
string lastName = Console.ReadLine(5, "Doe");
用户让第一个提示的超时到期，然后为第二个提示输入一个值。FirstName 和 LastName 都将包含默认值。当用户点击“回车”时， 第一的 ReadLine 调用将完成，但代码已放弃该调用并实质上丢弃了结果。这 第二 ReadLine 调用将继续阻塞，超时最终将到期，返回的值将再次成为默认值。
顺便说一句 - 上面的代码中有一个错误。通过调用 waitHandle.Close()，您可以从工作线程下关闭事件。如果用户在超时到期后按“回车”，工作线程将尝试发出引发 ObjectDisposeException 的事件信号。异常是从工作线程抛出的，如果您没有设置未处理的异常处理程序，您的进程将终止。
我可能对这个问题读得太多了，但我假设等待过程与启动菜单类似，除非您按下某个键，否则它会等待 15 秒。您可以使用 (1) 阻塞函数或 (2) 使用线程、事件和计时器。该事件将充当“继续”并阻塞，直到计时器到期或按下某个键。
(1) 的伪代码为：
// Get configurable wait time
TimeSpan waitTime = TimeSpan.FromSeconds(15.0);
int configWaitTimeSec;
if (int.TryParse(ConfigManager.AppSetting["DefaultWaitTime"], out configWaitTimeSec))
waitTime = TimeSpan.FromSeconds(configWaitTimeSec);
bool keyPressed = false;
DateTime expireTime = DateTime.Now + waitTime;
// Timer and key processor
ConsoleKeyInfo cki;
// EDIT: adding a missing ! below
while (!keyPressed && (DateTime.Now < expireTime))
{
if (Console.KeyAvailable)
{
cki = Console.ReadKey(true);
// TODO: Process key
keyPressed = true;
}
Thread.Sleep(10);
}
如果你在 Main() 方法，你不能使用 await, ，所以你必须使用 Task.WaitAny():
var task = Task.Factory.StartNew(Console.ReadLine);
var result = Task.WaitAny(new Task[] { task }, TimeSpan.FromSeconds(5)) == 0
? task.Result : string.Empty;
然而，C# 7.1 引入了创建异步的可能性 Main() 方法，所以最好使用 Task.WhenAny() 版本只要你有这个选项：
var task = Task.Factory.StartNew(Console.ReadLine);
var completedTask = await Task.WhenAny(task, Task.Delay(TimeSpan.FromSeconds(5)));
var result = object.ReferenceEquals(task, completedTask) ? task.Result : string.Empty;
不幸的是，我无法评论古尔扎尔的帖子，但这里有一个更完整的例子：
while (Console.KeyAvailable == false)
{
Thread.Sleep(250);
i++;
if (i > 3)
throw new Exception("Timedout waiting for input.");
}
input = Console.ReadLine();
编辑: ：通过在单独的进程中完成实际工作并在超时时终止该进程来解决该问题。详情请参阅下文。哇！
刚刚试了一下，似乎效果很好。我的同事有一个使用 Thread 对象的版本，但我发现委托类型的 BeginInvoke() 方法更优雅一些。
namespace TimedReadLine
{
public static class Console
{
private delegate string ReadLineInvoker();
public static string ReadLine(int timeout)
{
return ReadLine(timeout, null);
}
public static string ReadLine(int timeout, string @default)
{
using (var process = new System.Diagnostics.Process
{
StartInfo =
{
FileName = "ReadLine.exe",
RedirectStandardOutput = true,
UseShellExecute = false
}
})
{
process.Start();
var rli = new ReadLineInvoker(process.StandardOutput.ReadLine);
var iar = rli.BeginInvoke(null, null);
if (!iar.AsyncWaitHandle.WaitOne(new System.TimeSpan(0, 0, timeout)))
{
process.Kill();
return @default;
}
return rli.EndInvoke(iar);
}
}
}
}
ReadLine.exe 项目是一个非常简单的项目，它有一个类，如下所示：
namespace ReadLine
{
internal static class Program
{
private static void Main()
{
System.Console.WriteLine(System.Console.ReadLine());
}
}
}
.NET 4 使用任务使这变得异常简单。
首先，构建你的助手：
Private Function AskUser() As String
Console.Write("Answer my question: ")
Return Console.ReadLine()
End Function
其次，执行任务并等待：
Dim askTask As Task(Of String) = New TaskFactory().StartNew(Function() AskUser())
askTask.Wait(TimeSpan.FromSeconds(30))
If Not askTask.IsCompleted Then
Console.WriteLine("User failed to respond.")
Else
Console.WriteLine(String.Format("You responded, '{0}'.", askTask.Result))
End If
无需尝试重新创建 ReadLine 功能或执行其他危险的黑客行为来使其正常工作。任务让我们以非常自然的方式解决问题。
好像这里还没有足够的答案:0)，以下内容封装到上面 @kwl 的解决方案（第一个）的静态方法中。
public static string ConsoleReadLineWithTimeout(TimeSpan timeout)
{
Task<string> task = Task.Factory.StartNew(Console.ReadLine);
string result = Task.WaitAny(new Task[] { task }, timeout) == 0
? task.Result
: string.Empty;
return result;
}
用法
static void Main()
{
Console.WriteLine("howdy");
string result = ConsoleReadLineWithTimeout(TimeSpan.FromSeconds(8.5));
Console.WriteLine("bye");
}
简单的线程示例来解决这个问题
Thread readKeyThread = new Thread(ReadKeyMethod);
static ConsoleKeyInfo cki = null;
void Main()
{
readKeyThread.Start();
bool keyEntered = false;
for(int ii = 0; ii < 10; ii++)
{
Thread.Sleep(1000);
if(readKeyThread.ThreadState == ThreadState.Stopped)
keyEntered = true;
}
if(keyEntered)
{ //do your stuff for a key entered
}
}
void ReadKeyMethod()
{
cki = Console.ReadKey();
}
或顶部的静态字符串以获得整行。
我的情况这工作正常：
public static ManualResetEvent evtToWait = new ManualResetEvent(false);
private static void ReadDataFromConsole( object state )
{
Console.WriteLine("Enter \"x\" to exit or wait for 5 seconds.");
while (Console.ReadKey().KeyChar != 'x')
{
Console.Out.WriteLine("");
Console.Out.WriteLine("Enter again!");
}
evtToWait.Set();
}
static void Main(string[] args)
{
Thread status = new Thread(ReadDataFromConsole);
status.Start();
evtToWait = new ManualResetEvent(false);
evtToWait.WaitOne(5000); // wait for evtToWait.Set() or timeOut
status.Abort(); // exit anyway
return;
}
这不是又好又短吗？
if (SpinWait.SpinUntil(() => Console.KeyAvailable, millisecondsTimeout))
{
ConsoleKeyInfo keyInfo = Console.ReadKey();
// Handle keyInfo value here...
}
这是 Glen Slayden 解决方案的更完整示例。我在为另一个问题构建测试用例时碰巧做了这个。它使用异步 I/O 和手动重置事件。
public static void Main() {
bool readInProgress = false;
System.IAsyncResult result = null;
var stop_waiting = new System.Threading.ManualResetEvent(false);
byte[] buffer = new byte[256];
var s = System.Console.OpenStandardInput();
while (true) {
if (!readInProgress) {
readInProgress = true;
result = s.BeginRead(buffer, 0, buffer.Length
, ar => stop_waiting.Set(), null);
}
bool signaled = true;
if (!result.IsCompleted) {
stop_waiting.Reset();
signaled = stop_waiting.WaitOne(5000);
}
else {
signaled = true;
}
if (signaled) {
readInProgress = false;
int numBytes = s.EndRead(result);
string text = System.Text.Encoding.UTF8.GetString(buffer
, 0, numBytes);
System.Console.Out.Write(string.Format(
"Thank you for typing: {0}", text));
}
else {
System.Console.Out.WriteLine("oy, type something!");
}
}
获得第二个线程的另一种廉价方法是将其包装在委托中。
埃里克上面的帖子的示例实现。这个特定的示例用于读取通过管道传递到控制台应用程序的信息：
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
namespace PipedInfo
{
class Program
{
static void Main(string[] args)
{
StreamReader buffer = ReadPipedInfo();
Console.WriteLine(buffer.ReadToEnd());
}
#region ReadPipedInfo
public static StreamReader ReadPipedInfo()
{
//call with a default value of 5 milliseconds
return ReadPipedInfo(5);
}
public static StreamReader ReadPipedInfo(int waitTimeInMilliseconds)
{
//allocate the class we're going to callback to
ReadPipedInfoCallback callbackClass = new ReadPipedInfoCallback();
//to indicate read complete or timeout
AutoResetEvent readCompleteEvent = new AutoResetEvent(false);
//open the StdIn so that we can read against it asynchronously
Stream stdIn = Console.OpenStandardInput();
//allocate a one-byte buffer, we're going to read off the stream one byte at a time
byte[] singleByteBuffer = new byte[1];
//allocate a list of an arbitary size to store the read bytes
List<byte> byteStorage = new List<byte>(4096);
IAsyncResult asyncRead = null;
int readLength = 0; //the bytes we have successfully read
do
{
//perform the read and wait until it finishes, unless it's already finished
asyncRead = stdIn.BeginRead(singleByteBuffer, 0, singleByteBuffer.Length, new AsyncCallback(callbackClass.ReadCallback), readCompleteEvent);
if (!asyncRead.CompletedSynchronously)
readCompleteEvent.WaitOne(waitTimeInMilliseconds);
//end the async call, one way or another
//if our read succeeded we store the byte we read
if (asyncRead.IsCompleted)
{
readLength = stdIn.EndRead(asyncRead);
if (readLength > 0)
byteStorage.Add(singleByteBuffer[0]);
}
} while (asyncRead.IsCompleted && readLength > 0);
//we keep reading until we fail or read nothing
//return results, if we read zero bytes the buffer will return empty
return new StreamReader(new MemoryStream(byteStorage.ToArray(), 0, byteStorage.Count));
}
private class ReadPipedInfoCallback
{
public void ReadCallback(IAsyncResult asyncResult)
{
//pull the user-defined variable and strobe the event, the read finished successfully
AutoResetEvent readCompleteEvent = asyncResult.AsyncState as AutoResetEvent;
readCompleteEvent.Set();
}
}
#endregion ReadPipedInfo
}
}
string readline = "?";
ThreadPool.QueueUserWorkItem(
delegate
{
readline = Console.ReadLine();
}
);
do
{
Thread.Sleep(100);
} while (readline == "?");
请注意，如果您走“Console.ReadKey”路线，您将失去 ReadLine 的一些很酷的功能，即：
- 支持删除、退格键、方向键等。
- 能够按“向上”键并重复最后一个命令（如果您实现经常使用的后台调试控制台，这会非常方便）。
要添加超时，请更改 while 循环以适应。
请不要恨我在众多现有答案中添加另一个解决方案！这适用于 Console.ReadKey()，但可以轻松修改以与 ReadLine() 等一起使用。
由于“Console.Read”方法被阻塞，因此有必要“轻推" StdIn 流取消读取。
调用语法：
ConsoleKeyInfo keyInfo;
bool keyPressed = AsyncConsole.ReadKey(500, out keyInfo);
// where 500 is the timeout
代码：
public class AsyncConsole // not thread safe
{
private static readonly Lazy<AsyncConsole> Instance =
new Lazy<AsyncConsole>();
private bool _keyPressed;
private ConsoleKeyInfo _keyInfo;
private bool DoReadKey(
int millisecondsTimeout,
out ConsoleKeyInfo keyInfo)
{
_keyPressed = false;
_keyInfo = new ConsoleKeyInfo();
Thread readKeyThread = new Thread(ReadKeyThread);
readKeyThread.IsBackground = false;
readKeyThread.Start();
Thread.Sleep(millisecondsTimeout);
if (readKeyThread.IsAlive)
{
try
{
IntPtr stdin = GetStdHandle(StdHandle.StdIn);
CloseHandle(stdin);
readKeyThread.Join();
}
catch { }
}
readKeyThread = null;
keyInfo = _keyInfo;
return _keyPressed;
}
private void ReadKeyThread()
{
try
{
_keyInfo = Console.ReadKey();
_keyPressed = true;
}
catch (InvalidOperationException) { }
}
public static bool ReadKey(
int millisecondsTimeout,
out ConsoleKeyInfo keyInfo)
{
return Instance.Value.DoReadKey(millisecondsTimeout, out keyInfo);
}
private enum StdHandle { StdIn = -10, StdOut = -11, StdErr = -12 };
[DllImport("kernel32.dll")]
private static extern IntPtr GetStdHandle(StdHandle std);
[DllImport("kernel32.dll")]
private static extern bool CloseHandle(IntPtr hdl);
}
这是一个使用的解决方案 Console.KeyAvailable. 。这些是阻塞调用，但如果需要的话，通过 TPL 异步调用它们应该是相当简单的。我使用标准取消机制来轻松连接任务异步模式和所有这些好东西。
public static class ConsoleEx
{
public static string ReadLine(TimeSpan timeout)
{
var cts = new CancellationTokenSource();
return ReadLine(timeout, cts.Token);
}
public static string ReadLine(TimeSpan timeout, CancellationToken cancellation)
{
string line = "";
DateTime latest = DateTime.UtcNow.Add(timeout);
do
{
cancellation.ThrowIfCancellationRequested();
if (Console.KeyAvailable)
{
ConsoleKeyInfo cki = Console.ReadKey();
if (cki.Key == ConsoleKey.Enter)
{
return line;
}
else
{
line += cki.KeyChar;
}
}
Thread.Sleep(1);
}
while (DateTime.UtcNow < latest);
return null;
}
}
这样做有一些缺点。
- 您无法获得标准的导航功能
ReadLine提供（向上/向下箭头滚动等）。 - 如果按下特殊键（F1、PrtScn 等），这会将“\0”字符注入到输入中。不过，您可以通过修改代码轻松过滤掉它们。
因为提出了重复的问题而结束在这里。我想出了以下看起来简单的解决方案。我确信它有一些我错过的缺点。
static void Main(string[] args)
{
Console.WriteLine("Hit q to continue or wait 10 seconds.");
Task task = Task.Factory.StartNew(() => loop());
Console.WriteLine("Started waiting");
task.Wait(10000);
Console.WriteLine("Stopped waiting");
}
static void loop()
{
while (true)
{
if ('q' == Console.ReadKey().KeyChar) break;
}
}
我得出这个答案并最终做了：
/// <summary>
/// Reads Line from console with timeout.
/// </summary>
/// <exception cref="System.TimeoutException">If user does not enter line in the specified time.</exception>
/// <param name="timeout">Time to wait in milliseconds. Negative value will wait forever.</param>
/// <returns></returns>
public static string ReadLine(int timeout = -1)
{
ConsoleKeyInfo cki = new ConsoleKeyInfo();
StringBuilder sb = new StringBuilder();
// if user does not want to spesify a timeout
if (timeout < 0)
return Console.ReadLine();
int counter = 0;
while (true)
{
while (Console.KeyAvailable == false)
{
counter++;
Thread.Sleep(1);
if (counter > timeout)
throw new System.TimeoutException("Line was not entered in timeout specified");
}
cki = Console.ReadKey(false);
if (cki.Key == ConsoleKey.Enter)
{
Console.WriteLine();
return sb.ToString();
}
else
sb.Append(cki.KeyChar);
}
}
一个简单的例子使用 Console.KeyAvailable:
Console.WriteLine("Press any key during the next 2 seconds...");
Thread.Sleep(2000);
if (Console.KeyAvailable)
{
Console.WriteLine("Key pressed");
}
else
{
Console.WriteLine("You were too slow");
}
更现代和基于任务的代码看起来像这样：
public string ReadLine(int timeOutMillisecs)
{
var inputBuilder = new StringBuilder();
var task = Task.Factory.StartNew(() =>
{
while (true)
{
var consoleKey = Console.ReadKey(true);
if (consoleKey.Key == ConsoleKey.Enter)
{
return inputBuilder.ToString();
}
inputBuilder.Append(consoleKey.KeyChar);
}
});
var success = task.Wait(timeOutMillisecs);
if (!success)
{
throw new TimeoutException("User did not provide input within the timelimit.");
}
return inputBuilder.ToString();
}
我有一个独特的情况，拥有一个 Windows 应用程序（Windows 服务）。交互运行程序时 Environment.IsInteractive （VS 调试器或来自 cmd.exe），我使用 AttachConsole/AllocConsole 来获取我的标准输入/标准输出。为了防止进程在工作完成时结束，UI 线程调用 Console.ReadKey(false). 。我想从另一个线程取消 UI 线程正在执行的等待，因此我对 @JSquaredD 的解决方案进行了修改。
using System;
using System.Diagnostics;
internal class PressAnyKey
{
private static Thread inputThread;
private static AutoResetEvent getInput;
private static AutoResetEvent gotInput;
private static CancellationTokenSource cancellationtoken;
static PressAnyKey()
{
// Static Constructor called when WaitOne is called (technically Cancel too, but who cares)
getInput = new AutoResetEvent(false);
gotInput = new AutoResetEvent(false);
inputThread = new Thread(ReaderThread);
inputThread.IsBackground = true;
inputThread.Name = "PressAnyKey";
inputThread.Start();
}
private static void ReaderThread()
{
while (true)
{
// ReaderThread waits until PressAnyKey is called
getInput.WaitOne();
// Get here
// Inner loop used when a caller uses PressAnyKey
while (!Console.KeyAvailable && !cancellationtoken.IsCancellationRequested)
{
Thread.Sleep(50);
}
// Release the thread that called PressAnyKey
gotInput.Set();
}
}
/// <summary>
/// Signals the thread that called WaitOne should be allowed to continue
/// </summary>
public static void Cancel()
{
// Trigger the alternate ending condition to the inner loop in ReaderThread
if(cancellationtoken== null) throw new InvalidOperationException("Must call WaitOne before Cancelling");
cancellationtoken.Cancel();
}
/// <summary>
/// Wait until a key is pressed or <see cref="Cancel"/> is called by another thread
/// </summary>
public static void WaitOne()
{
if(cancellationtoken==null || cancellationtoken.IsCancellationRequested) throw new InvalidOperationException("Must cancel a pending wait");
cancellationtoken = new CancellationTokenSource();
// Release the reader thread
getInput.Set();
// Calling thread will wait here indefiniately
// until a key is pressed, or Cancel is called
gotInput.WaitOne();
}
}
这似乎是最简单、可行的解决方案，不使用任何本机 API：
static Task<string> ReadLineAsync(CancellationToken cancellation)
{
return Task.Run(() =>
{
while (!Console.KeyAvailable)
{
if (cancellation.IsCancellationRequested)
return null;
Thread.Sleep(100);
}
return Console.ReadLine();
});
}
用法示例：
static void Main(string[] args)
{
AsyncContext.Run(async () =>
{
CancellationTokenSource cancelSource = new CancellationTokenSource();
cancelSource.CancelAfter(1000);
Console.WriteLine(await ReadLineAsync(cancelSource.Token) ?? "null");
});
}
不隶属于 StackOverflow
