Comment ajouter un délai d'attente à Console.ReadLine() ?

Question

J'ai une application console dans laquelle je veux donner à l'utilisateur x secondes pour répondre à l'invite. Si aucune entrée n'est effectuée après un certain temps, la logique du programme doit continuer. Nous supposons qu'un délai d'attente signifie une réponse vide.

Quelle est la manière la plus simple d'aborder cette question ?

Answer 1

Je suis surpris d'apprendre qu'après 5 ans, toutes les réponses souffrent encore d'un ou plusieurs des problèmes suivants:

• Une fonction autre que celle ReadLine est utilisée, causant une perte de fonctionnalité. (Supprimer/retour arrière/haut-clé pour l'entrée précédente).
• La fonction se comporte mal quand il est invoqué à plusieurs reprises (la ponte de plusieurs threads, beaucoup de pendaison de ReadLine, ou sinon un comportement inattendu).
• Fonction s'appuie sur un week-attendre. Ce qui est horrible déchets car l'attente est prévu pour fonctionner n'importe où à partir d'un certain nombre de secondes jusqu'à l'expiration, qui peut être de plusieurs minutes. Un occupé-attendre, s'étendant sur une telle quantité de temps est horrible sucer des ressources, ce qui est particulièrement mauvais dans un multithreading scénario. Si les occupé-attendre est modifié avec un sommeil, ce qui a un effet négatif sur la réactivité, même si j'avoue que ce n'est probablement pas un énorme problème.

Je crois que ma solution va résoudre le problème d'origine, sans souffrir d'aucun des problèmes ci-dessus:

class Reader {
  private static Thread inputThread;
  private static AutoResetEvent getInput, gotInput;
  private static string input;

  static Reader() {
    inputThread = new Thread(reader);
    inputThread.IsBackground = true;
    inputThread.Start();
    getInput = new AutoResetEvent(false);
    gotInput = new AutoResetEvent(false);
  }

  private static void reader() {
    while (true) {
      getInput.WaitOne();
      input = Console.ReadLine();
      gotInput.Set();
    }
  }

  public static string ReadLine(int timeOutMillisecs) {
    getInput.Set();
    bool success = gotInput.WaitOne(timeOutMillisecs);
    if (success)
      return input;
    else
      throw new TimeoutException("User did not provide input within the timelimit.");
  }
}

L'appel est, bien sûr, très facile:

try {
  Console.WriteLine("Please enter your name within the next 5 seconds.");
  string name = Reader.ReadLine(5000);
} catch (TimeoutException) {
  Console.WriteLine("Sorry, you waited too long.");
} 

Alors, comment au sujet de ces problèmes de les autres solutions que j'ai mentionné?

• Comme vous pouvez le voir, ReadLine est utilisée, évitant ainsi le premier problème.
• La fonction se comporte correctement lorsqu'il est appelé à de multiples reprises. Indépendamment de savoir si un délai d'attente se produit ou pas, un seul thread d'arrière-plan ne sera jamais en cours d'exécution et au plus un appel à l'ReadLine sera jamais actif. L'appel de la fonction se traduit toujours par la dernière entrée, ou dans un délai d'expiration, et l'utilisateur n'aura pas à frapper participer plus d'une fois à présenter son entrée.
• Et, évidemment, la fonction ne dépend pas d'un occupé-attendre. Au lieu de cela il utilise la bonne techniques de multithreading pour éviter de gaspiller des ressources.

Le seul problème que j'entrevois avec cette solution est qu'elle n'est pas thread-safe. Cependant, plusieurs threads ne pouvez pas vraiment demander à l'utilisateur pour entrer dans le même temps, de sorte que la synchronisation doit se faire avant de faire un appel à l' Reader.ReadLine de toute façon.

Answer 2

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();

Answer 3

Est-ce que cette approche utilisant Console.KeyAvailable de l'aide ?

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);
    }
}

Answer 4

D'une façon ou d'une autre vous avez besoin d'un deuxième thread. Vous pouvez utiliser asynchrone IO pour éviter de déclarer votre propre:

• déclarer un ManualResetEvent, de l'appeler "evt"
• Système d'appel.Console.OpenStandardInput pour obtenir le flux d'entrée. Spécifier une méthode de rappel que pour le stockage de ses données et de définir des evt.
• appel du flux BeginRead méthode pour démarrer une opération de lecture asynchrone
• entrez ensuite un temps d'attente sur un ManualResetEvent
• si le temps d'attente, puis annuler la lecture

Si la lecture renvoie les données, définir l'événement et de votre thread principal va continuer, sinon, vous allez continuer après l'expiration du délai.

Answer 5

Je pense que vous devrez créer un fil secondaire et demander une clé sur la console. Je ne connais pas de moyen intégré pour accomplir cela.