Asked  6 Months ago    Answers:  5   Viewed   53 times

I have a console app in which I want to give the user x seconds to respond to the prompt. If no input is made after a certain period of time, program logic should continue. We assume a timeout means empty response.

What is the most straightforward way of approaching this?



I'm surprised to learn that after 5 years, all of the answers still suffer from one or more of the following problems:

  • A function other than ReadLine is used, causing loss of functionality. (Delete/backspace/up-key for previous input).
  • Function behaves badly when invoked multiple times (spawning multiple threads, many hanging ReadLine's, or otherwise unexpected behavior).
  • Function relies on a busy-wait. Which is a horrible waste since the wait is expected to run anywhere from a number of seconds up to the timeout, which might be multiple minutes. A busy-wait which runs for such an ammount of time is a horrible suck of resources, which is especially bad in a multithreading scenario. If the busy-wait is modified with a sleep this has a negative effect on responsiveness, although I admit that this is probably not a huge problem.

I believe my solution will solve the original problem without suffering from any of the above problems:

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;

  private static void reader() {
    while (true) {
      input = Console.ReadLine();

  // omit the parameter to read a line without a timeout
  public static string ReadLine(int timeOutMillisecs = Timeout.Infinite) {
    bool success = gotInput.WaitOne(timeOutMillisecs);
    if (success)
      return input;
      throw new TimeoutException("User did not provide input within the timelimit.");

Calling is, of course, very easy:

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.");

Alternatively, you can use the TryXX(out) convention, as shmueli suggested:

  public static bool TryReadLine(out string line, int timeOutMillisecs = Timeout.Infinite) {
    bool success = gotInput.WaitOne(timeOutMillisecs);
    if (success)
      line = input;
      line = null;
    return success;

Which is called as follows:

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.");
  Console.WriteLine("Hello, {0}!", name);

In both cases, you cannot mix calls to Reader with normal Console.ReadLine calls: if the Reader times out, there will be a hanging ReadLine call. Instead, if you want to have a normal (non-timed) ReadLine call, just use the Reader and omit the timeout, so that it defaults to an infinite timeout.

So how about those problems of the other solutions I mentioned?

  • As you can see, ReadLine is used, avoiding the first problem.
  • The function behaves properly when invoked multiple times. Regardless of whether a timeout occurs or not, only one background thread will ever be running and only at most one call to ReadLine will ever be active. Calling the function will always result in the latest input, or in a timeout, and the user won't have to hit enter more than once to submit his input.
  • And, obviously, the function does not rely on a busy-wait. Instead it uses proper multithreading techniques to prevent wasting resources.

The only problem that I foresee with this solution is that it is not thread-safe. However, multiple threads can't really ask the user for input at the same time, so synchronization should be happening before making a call to Reader.ReadLine anyway.

Tuesday, June 1, 2021
answered 6 Months ago

This question was asked over 9 years ago, and Python has changed a decent amount since then as has my repertoire of experience. After reviewing other APIs in the standard library and wanting to partially replicate one in particular, the follow module was written to serve a similar purpose as the one posted in the question.

#! /usr/bin/env python3
import _thread
import abc as _abc
import collections as _collections
import enum as _enum
import math as _math
import multiprocessing as _multiprocessing
import operator as _operator
import queue as _queue
import signal as _signal
import sys as _sys
import time as _time

__all__ = (

class _Base(metaclass=_abc.ABCMeta):
    __slots__ = (

    def __init__(self, timeout):
        self.timeout = _math.inf if timeout is None else timeout

    def get_timeout(self):
        return self.__timeout

    def set_timeout(self, value):
        if not isinstance(value, (float, int)):
            raise TypeError('value must be of type float or int')
        if value <= 0:
            raise ValueError('value must be greater than zero')
        self.__timeout = value

    timeout = property(get_timeout, set_timeout)

def _run_and_catch(fn, args, kwargs):
    # noinspection PyPep8,PyBroadException
        return False, fn(*args, **kwargs)
        return True, _sys.exc_info()[1]

def _run(fn, args, kwargs, queue):
    queue.put_nowait(_run_and_catch(fn, args, kwargs))

class _State(_enum.IntEnum):
    ERROR =

def _run_and_catch_loop(iterable, *args, **kwargs):
    exception = None
    for fn in iterable:
        error, value = _run_and_catch(fn, args, kwargs)
        if error:
            exception = value
    if exception:
        raise exception

class _Future(_Base):
    __slots__ = (

    def __init__(self, timeout, fn, args, kwargs):
        self.__queue = _multiprocessing.Queue(1)
        self.__process = _multiprocessing.Process(
            args=(fn, args, kwargs, self.__queue),
        self.__start_time = _math.inf
        self.__callbacks = _collections.deque()
        self.__result = True, TimeoutError()
        self.__mutex = _thread.allocate_lock()

    def __state(self):
        pid, exitcode =, self.__process.exitcode
        return (_State.PENDING if pid is None else
                _State.RUNNING if exitcode is None else
                _State.CANCELLED if exitcode == -_signal.SIGTERM else
                _State.FINISHED if exitcode == 0 else

    def __repr__(self):
        root = f'{type(self).__name__} at {id(self)} state={}'
        if self.__state < _State.CANCELLED:
            return f'<{root}>'
        error, value = self.__result
        suffix = f'{"raised" if error else "returned"} {type(value).__name__}'
        return f'<{root} {suffix}>'

    def __consume_callbacks(self):
        while self.__callbacks:
            yield self.__callbacks.popleft()

    def __invoke_callbacks(self):
        _run_and_catch_loop(self.__consume_callbacks(), self)

    def cancel(self):

    def __auto_cancel(self):
        elapsed_time = _time.perf_counter() - self.__start_time
        if elapsed_time > self.timeout:
        return elapsed_time

    def cancelled(self):
        return self.__state is _State.CANCELLED

    def running(self):
        return self.__state is _State.RUNNING

    def done(self):
        return self.__state > _State.RUNNING

    def __handle_result(self, error, value):
        self.__result = error, value

    def __ensure_termination(self):
        with self.__mutex:
            elapsed_time = self.__auto_cancel()
            if not self.__queue.empty():
            elif self.__state < _State.CANCELLED:
                remaining_time = self.timeout - elapsed_time
                if remaining_time == _math.inf:
                    remaining_time = None
                    result = self.__queue.get(True, remaining_time)
                except _queue.Empty:

    def result(self):
        error, value = self.__result
        if error:
            raise value
        return value

    def exception(self):
        error, value = self.__result
        if error:
            return value

    def add_done_callback(self, fn):
        if self.done():

    def _set_running_or_notify_cancel(self):
        if self.__state is _State.PENDING:
            self.__start_time = _time.perf_counter()

class Executor(_Base):
    __slots__ = (

    def __init__(self, timeout=None):
        self.__futures = set()

    def submit(self, fn, *args, **kwargs):
        future = _Future(self.timeout, fn, args, kwargs)
        # noinspection PyProtectedMember
        return future

    def __cancel_futures(iterable):
        _run_and_catch_loop(map(_operator.attrgetter('cancel'), iterable))

    def map(self, fn, *iterables):
        futures = tuple(self.submit(fn, *args) for args in zip(*iterables))

        def result_iterator():
            future_iterator = iter(futures)
                for future in future_iterator:
                    yield future.result()

        return result_iterator()

    def shutdown(self):

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        return False

_executor = Executor()
get_timeout = _executor.get_timeout
set_timeout = _executor.set_timeout
submit = _executor.submit
map_ =
shutdown = _executor.shutdown
del _executor
Sunday, June 13, 2021
answered 6 Months ago

Whilst slightly outside of the scope of my original requirements, I have found a solution to the problem that I can work with.

As it turns out, if you receive an email with a vcard in it as an attachment, then you are able to open this attachment and add it to your address book. So, if instead of offering a vcard download link to iPhone users you provide them with a way to be sent the vcard via email instead then they are able to add the card to their address book.

A slightly roundabout solution, but about the best I'm able to come up with whilst Apple don't allow you to do it natively. Certainly it's a better solution than doing nothing at all.

I ended up writing a blog post about this: Adding a vCard to your iPhone Address Book from a web page

Wednesday, July 28, 2021
answered 4 Months ago

The issue was solved using Hans' comment above.

Sounds to me that you've activated the console window's Mark and Paste commands somehow. Normally activate through the system menu (Alt + Space, Edit, Mark/Paste). That doesn't have anything to do with this code of course.

Apparently, Quick Edit Mode was set in the console defaults (Alt + Space, Defaults, Options, Edit Options, Quick Edit Mode) for some reason. Unchecking that resolved the issue.

Thursday, July 29, 2021
answered 4 Months ago

From .Net Framework 2.0 and beyond, you can change the buffer height from within your own program with Console.BufferHeight:

Console.BufferHeight = Int16.MaxValue - 1; // ***** Alters the BufferHeight *****
List<string> myList = new List<string>();
for (int x = 0; x < 100000; x++) 
foreach (string s in myList) { 

The maximum height is Int16.MaxValue - 1.

Friday, August 6, 2021
answered 4 Months ago
Only authorized users can answer the question. Please sign in first, or register a free account.
Not the answer you're looking for? Browse other questions tagged :