SpeechRecognitionEngine.RecognizeAsync Méthode

Référence

Définition

Espace de noms:: System.Speech.Recognition

Assembly:: System.Speech.dll

Paquet:: System.Speech v8.0.0

Paquet:: System.Speech v9.0.0-rc.2.24473.5

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Démarre une opération de reconnaissance vocale asynchrone.

Surcharges

RecognizeAsync()	Effectue une opération de reconnaissance vocale unique et asynchrone.
RecognizeAsync(RecognizeMode)	Exécute une ou plusieurs opérations de reconnaissance vocale asynchrones.

Remarques

Ces méthodes effectuent des opérations de reconnaissance asynchrones uniques ou multiples. Le module de reconnaissance effectue chaque opération par rapport à ses grammaires de reconnaissance vocale chargées et activées.

Lors d’un appel à cette méthode, le module de reconnaissance peut déclencher les événements suivants :

SpeechDetected. Déclenché lorsque le module de reconnaissance détecte une entrée qu’il peut identifier en tant que reconnaissance vocale.
SpeechHypothesized. Déclenché lorsque l’entrée crée une correspondance ambiguë avec l’une des grammaires actives.
SpeechRecognitionRejected ou SpeechRecognized. Déclenché lorsque le module de reconnaissance finalise une opération de reconnaissance.
RecognizeCompleted. Déclenché lorsqu’une RecognizeAsync opération se termine.

Pour récupérer le résultat d’une opération de reconnaissance asynchrone, attachez un gestionnaire d’événements à l’événement du module de SpeechRecognized reconnaissance. Le module de reconnaissance déclenche cet événement chaque fois qu’il termine avec succès une opération de reconnaissance synchrone ou asynchrone. Si la reconnaissance n’a pas réussi, la Result propriété sur RecognizeCompletedEventArgs l’objet, à laquelle vous pouvez accéder dans le gestionnaire de l’événement RecognizeCompleted , sera null.

Une opération de reconnaissance asynchrone peut échouer pour les raisons suivantes :

La reconnaissance vocale n’est pas détectée avant l’expiration des intervalles de délai d’expiration pour les BabbleTimeout propriétés ou InitialSilenceTimeout .
Le moteur de reconnaissance détecte la parole, mais ne trouve aucune correspondance dans ses objets chargés et activés Grammar .
Le doit avoir au moins un objet chargé avant d’effectuer Grammar la SpeechRecognitionEngine reconnaissance. Pour charger une grammaire de reconnaissance vocale, utilisez la LoadGrammar méthode ou LoadGrammarAsync .
Pour modifier la façon dont le module de reconnaissance gère le minutage de la parole ou du silence en ce qui concerne la reconnaissance, utilisez les BabbleTimeoutpropriétés , InitialSilenceTimeout, EndSilenceTimeoutet EndSilenceTimeoutAmbiguous .
Pour effectuer une reconnaissance synchrone, utilisez l’une des Recognize méthodes .

RecognizeAsync()

Source:: SpeechRecognitionEngine.cs

Source:: SpeechRecognitionEngine.cs

Effectue une opération de reconnaissance vocale unique et asynchrone.

public:
 void RecognizeAsync();

public void RecognizeAsync ();

member this.RecognizeAsync : unit -> unit

Public Sub RecognizeAsync ()

Exemples

L’exemple suivant montre une partie d’une application console qui illustre la reconnaissance vocale asynchrone de base. L’exemple crée un DictationGrammar, le charge dans un module de reconnaissance vocale in-process et effectue une opération de reconnaissance asynchrone. Des gestionnaires d’événements sont inclus pour illustrer les événements que le module de reconnaissance déclenche pendant l’opération.

using System;  
using System.Globalization;  
using System.Speech.Recognition;  
using System.Threading;  

namespace AsynchronousRecognition  
{  
  class Program  
  {  
    // Indicate whether asynchronous recognition is complete.  
    static bool completed;  

    static void Main(string[] args)  
    {  
      // Create an in-process speech recognizer.  
      using (SpeechRecognitionEngine recognizer =  
        new SpeechRecognitionEngine(new CultureInfo("en-US")))  
      {  
        // Create a grammar for choosing cities for a flight.  
        Choices cities = new Choices(new string[]   
        { "Los Angeles", "New York", "Chicago", "San Francisco", "Miami", "Dallas" });  

        GrammarBuilder gb = new GrammarBuilder();  
        gb.Append("I want to fly from");  
        gb.Append(cities);  
        gb.Append("to");  
        gb.Append(cities);  

        // Construct a Grammar object and load it to the recognizer.  
        Grammar cityChooser = new Grammar(gb);  
        cityChooser.Name = ("City Chooser");  
        recognizer.LoadGrammarAsync(cityChooser);  

        // Attach event handlers.  
        recognizer.SpeechDetected +=  
          new EventHandler<SpeechDetectedEventArgs>(  
            SpeechDetectedHandler);  
        recognizer.SpeechHypothesized +=  
          new EventHandler<SpeechHypothesizedEventArgs>(  
            SpeechHypothesizedHandler);  
        recognizer.SpeechRecognitionRejected +=  
          new EventHandler<SpeechRecognitionRejectedEventArgs>(  
            SpeechRecognitionRejectedHandler);  
        recognizer.SpeechRecognized +=  
          new EventHandler<SpeechRecognizedEventArgs>(  
            SpeechRecognizedHandler);  
        recognizer.RecognizeCompleted +=  
          new EventHandler<RecognizeCompletedEventArgs>(  
            RecognizeCompletedHandler);  

        // Assign input to the recognizer and start an asynchronous  
        // recognition operation.  
        recognizer.SetInputToDefaultAudioDevice();  

        completed = false;  
        Console.WriteLine("Starting asynchronous recognition...");  
        recognizer.RecognizeAsync();  

        // Wait for the operation to complete.  
        while (!completed)  
        {  
          Thread.Sleep(333);  
        }  
        Console.WriteLine("Done.");  
      }  

      Console.WriteLine();  
      Console.WriteLine("Press any key to exit...");  
      Console.ReadKey();  
    }  

    // Handle the SpeechDetected event.  
    static void SpeechDetectedHandler(object sender, SpeechDetectedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechDetectedHandler:");  
      Console.WriteLine(" - AudioPosition = {0}", e.AudioPosition);  
    }  

    // Handle the SpeechHypothesized event.  
    static void SpeechHypothesizedHandler(  
      object sender, SpeechHypothesizedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechHypothesizedHandler:");  

      string grammarName = "<not available>";  
      string resultText = "<not available>";  
      if (e.Result != null)  
      {  
        if (e.Result.Grammar != null)  
        {  
          grammarName = e.Result.Grammar.Name;  
        }  
        resultText = e.Result.Text;  
      }  

      Console.WriteLine(" - Grammar Name = {0}; Result Text = {1}",  
        grammarName, resultText);  
    }  

    // Handle the SpeechRecognitionRejected event.  
    static void SpeechRecognitionRejectedHandler(  
      object sender, SpeechRecognitionRejectedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechRecognitionRejectedHandler:");  

      string grammarName = "<not available>";  
      string resultText = "<not available>";  
      if (e.Result != null)  
      {  
        if (e.Result.Grammar != null)  
        {  
          grammarName = e.Result.Grammar.Name;  
        }  
        resultText = e.Result.Text;  
      }  

      Console.WriteLine(" - Grammar Name = {0}; Result Text = {1}",  
        grammarName, resultText);  
    }  

    // Handle the SpeechRecognized event.  
    static void SpeechRecognizedHandler(  
      object sender, SpeechRecognizedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechRecognizedHandler.");  

      string grammarName = "<not available>";  
      string resultText = "<not available>";  
      if (e.Result != null)  
      {  
        if (e.Result.Grammar != null)  
        {  
          grammarName = e.Result.Grammar.Name;  
        }  
        resultText = e.Result.Text;  
      }  

      Console.WriteLine(" - Grammar Name = {0}; Result Text = {1}",  
        grammarName, resultText);  
    }  

    // Handle the RecognizeCompleted event.  
    static void RecognizeCompletedHandler(  
      object sender, RecognizeCompletedEventArgs e)  
    {  
      Console.WriteLine(" In RecognizeCompletedHandler.");  

      if (e.Error != null)  
      {  
        Console.WriteLine(  
          " - Error occurred during recognition: {0}", e.Error);  
        return;  
      }  
      if (e.InitialSilenceTimeout || e.BabbleTimeout)  
      {  
        Console.WriteLine(  
          " - BabbleTimeout = {0}; InitialSilenceTimeout = {1}",  
          e.BabbleTimeout, e.InitialSilenceTimeout);  
        return;  
      }  
      if (e.InputStreamEnded)  
      {  
        Console.WriteLine(  
          " - AudioPosition = {0}; InputStreamEnded = {1}",  
          e.AudioPosition, e.InputStreamEnded);  
      }  
      if (e.Result != null)  
      {  
        Console.WriteLine(  
          " - Grammar = {0}; Text = {1}; Confidence = {2}",  
          e.Result.Grammar.Name, e.Result.Text, e.Result.Confidence);  
        Console.WriteLine(" - AudioPosition = {0}", e.AudioPosition);  
      }  
      else  
      {  
        Console.WriteLine(" - No result.");  
      }  

      completed = true;  
    }  
  }  
}

Remarques

Cette méthode effectue une seule opération de reconnaissance asynchrone. Le module de reconnaissance effectue l’opération sur ses grammaires de reconnaissance vocale chargées et activées.

Lors d’un appel à cette méthode, le module de reconnaissance peut déclencher les événements suivants :

SpeechDetected. Déclenché lorsque le module de reconnaissance détecte une entrée qu’il peut identifier en tant que reconnaissance vocale.
SpeechHypothesized. Déclenché lorsque l’entrée crée une correspondance ambiguë avec l’une des grammaires actives.
SpeechRecognitionRejected ou SpeechRecognized. Déclenché lorsque le module de reconnaissance finalise une opération de reconnaissance.
RecognizeCompleted. Déclenché lorsqu’une RecognizeAsync opération se termine.

Pour effectuer une reconnaissance synchrone, utilisez l’une des Recognize méthodes .

Cette méthode stocke dans la tâche toutes les exceptions de non-utilisation que le équivalent synchrone de la méthode peut lever. Si une exception est stockée dans la tâche retournée, cette exception est levée lorsque la tâche est attendue. Les exceptions d’utilisation, telles que ArgumentException, sont toujours levées de manière synchrone. Pour les exceptions stockées, consultez les exceptions levées par Recognize().

Voir aussi

S’applique à

RecognizeAsync(RecognizeMode)

Source:: SpeechRecognitionEngine.cs

Source:: SpeechRecognitionEngine.cs

Exécute une ou plusieurs opérations de reconnaissance vocale asynchrones.

public:
 void RecognizeAsync(System::Speech::Recognition::RecognizeMode mode);

public void RecognizeAsync (System.Speech.Recognition.RecognizeMode mode);

member this.RecognizeAsync : System.Speech.Recognition.RecognizeMode -> unit

Public Sub RecognizeAsync (mode As RecognizeMode)

Paramètres

mode: RecognizeMode

Indique s'il faut exécuter une ou de plusieurs opérations de reconnaissance.

Exemples

L’exemple suivant montre une partie d’une application console qui illustre la reconnaissance vocale asynchrone de base. L’exemple crée un DictationGrammar, le charge dans un module de reconnaissance vocale in-process et effectue plusieurs opérations de reconnaissance asynchrone. Les opérations asynchrones sont annulées après 30 secondes. Des gestionnaires d’événements sont inclus pour illustrer les événements que le module de reconnaissance déclenche pendant l’opération.

using System;  
using System.Globalization;  
using System.Speech.Recognition;  
using System.Threading;  

namespace AsynchronousRecognition  
{  
  class Program  
  {  
    // Indicate whether asynchronous recognition is complete.  
    static bool completed;  

    static void Main(string[] args)  
    {  
      // Create an in-process speech recognizer.  
      using (SpeechRecognitionEngine recognizer =  
        new SpeechRecognitionEngine(new CultureInfo("en-US")))  
      {  
        // Create a grammar for choosing cities for a flight.  
        Choices cities = new Choices(new string[] { "Los Angeles", "New York", "Chicago", "San Francisco", "Miami", "Dallas" });  

        GrammarBuilder gb = new GrammarBuilder();  
        gb.Append("I want to fly from");  
        gb.Append(cities);  
        gb.Append("to");  
        gb.Append(cities);  

        // Construct a Grammar object and load it to the recognizer.  
        Grammar cityChooser = new Grammar(gb);  
        cityChooser.Name = ("City Chooser");  
        recognizer.LoadGrammarAsync(cityChooser);  

        // Attach event handlers.  
        recognizer.SpeechDetected +=  
          new EventHandler<SpeechDetectedEventArgs>(  
            SpeechDetectedHandler);  
        recognizer.SpeechHypothesized +=  
          new EventHandler<SpeechHypothesizedEventArgs>(  
            SpeechHypothesizedHandler);  
        recognizer.SpeechRecognitionRejected +=  
          new EventHandler<SpeechRecognitionRejectedEventArgs>(  
            SpeechRecognitionRejectedHandler);  
        recognizer.SpeechRecognized +=  
          new EventHandler<SpeechRecognizedEventArgs>(  
            SpeechRecognizedHandler);  
        recognizer.RecognizeCompleted +=  
          new EventHandler<RecognizeCompletedEventArgs>(  
            RecognizeCompletedHandler);  

        // Assign input to the recognizer and start asynchronous  
        // recognition.  
        recognizer.SetInputToDefaultAudioDevice();  

        completed = false;  
        Console.WriteLine("Starting asynchronous recognition...");  
        recognizer.RecognizeAsync(RecognizeMode.Multiple);  

        // Wait 30 seconds, and then cancel asynchronous recognition.  
        Thread.Sleep(TimeSpan.FromSeconds(30));  
        recognizer.RecognizeAsyncCancel();  

        // Wait for the operation to complete.  
        while (!completed)  
        {  
          Thread.Sleep(333);  
        }  
        Console.WriteLine("Done.");  
      }  

      Console.WriteLine();  
      Console.WriteLine("Press any key to exit...");  
      Console.ReadKey();  
    }  

    // Handle the SpeechDetected event.  
    static void SpeechDetectedHandler(object sender, SpeechDetectedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechDetectedHandler:");  
      Console.WriteLine(" - AudioPosition = {0}", e.AudioPosition);  
    }  

    // Handle the SpeechHypothesized event.  
    static void SpeechHypothesizedHandler(  
      object sender, SpeechHypothesizedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechHypothesizedHandler:");  

      string grammarName = "<not available>";  
      string resultText = "<not available>";  
      if (e.Result != null)  
      {  
        if (e.Result.Grammar != null)  
        {  
          grammarName = e.Result.Grammar.Name;  
        }  
        resultText = e.Result.Text;  
      }  

      Console.WriteLine(" - Grammar Name = {0}; Result Text = {1}",  
        grammarName, resultText);  
    }  

    // Handle the SpeechRecognitionRejected event.  
    static void SpeechRecognitionRejectedHandler(  
      object sender, SpeechRecognitionRejectedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechRecognitionRejectedHandler:");  

      string grammarName = "<not available>";  
      string resultText = "<not available>";  
      if (e.Result != null)  
      {  
        if (e.Result.Grammar != null)  
        {  
          grammarName = e.Result.Grammar.Name;  
        }  
        resultText = e.Result.Text;  
      }  

      Console.WriteLine(" - Grammar Name = {0}; Result Text = {1}",  
        grammarName, resultText);  
    }  

    // Handle the SpeechRecognized event.  
    static void SpeechRecognizedHandler(  
      object sender, SpeechRecognizedEventArgs e)  
    {  
      Console.WriteLine(" In SpeechRecognizedHandler.");  

      string grammarName = "<not available>";  
      string resultText = "<not available>";  
      if (e.Result != null)  
      {  
        if (e.Result.Grammar != null)  
        {  
          grammarName = e.Result.Grammar.Name;  
        }  
        resultText = e.Result.Text;  
      }  

      Console.WriteLine(" - Grammar Name = {0}; Result Text = {1}",  
        grammarName, resultText);  
    }  

    // Handle the RecognizeCompleted event.  
    static void RecognizeCompletedHandler(  
      object sender, RecognizeCompletedEventArgs e)  
    {  
      Console.WriteLine(" In RecognizeCompletedHandler.");  

      if (e.Error != null)  
      {  
        Console.WriteLine(  
          " - Error occurred during recognition: {0}", e.Error);  
        return;  
      }  
      if (e.InitialSilenceTimeout || e.BabbleTimeout)  
      {  
        Console.WriteLine(  
          " - BabbleTimeout = {0}; InitialSilenceTimeout = {1}",  
          e.BabbleTimeout, e.InitialSilenceTimeout);  
        return;  
      }  
      if (e.InputStreamEnded)  
      {  
        Console.WriteLine(  
          " - AudioPosition = {0}; InputStreamEnded = {1}",  
          e.AudioPosition, e.InputStreamEnded);  
      }  
      if (e.Result != null)  
      {  
        Console.WriteLine(  
          " - Grammar = {0}; Text = {1}; Confidence = {2}",  
          e.Result.Grammar.Name, e.Result.Text, e.Result.Confidence);  
        Console.WriteLine(" - AudioPosition = {0}", e.AudioPosition);  
      }  
      else  
      {  
        Console.WriteLine(" - No result.");  
      }  

      completed = true;  
    }  
  }  
}

Remarques

Si mode a la valeur Multiple, le module de reconnaissance continue d’effectuer des opérations de reconnaissance asynchrones jusqu’à ce que la RecognizeAsyncCancel méthode ou RecognizeAsyncStop soit appelée.

Lors d’un appel à cette méthode, le module de reconnaissance peut déclencher les événements suivants :

SpeechDetected. Déclenché lorsque le module de reconnaissance détecte une entrée qu’il peut identifier en tant que reconnaissance vocale.
SpeechHypothesized. Déclenché lorsque l’entrée crée une correspondance ambiguë avec l’une des grammaires actives.
SpeechRecognitionRejected ou SpeechRecognized. Déclenché lorsque le module de reconnaissance finalise une opération de reconnaissance.
RecognizeCompleted. Déclenché lorsqu’une RecognizeAsync opération se termine.

Une opération de reconnaissance asynchrone peut échouer pour les raisons suivantes :

La reconnaissance vocale n’est pas détectée avant l’expiration des intervalles de délai d’expiration pour les BabbleTimeout propriétés ou InitialSilenceTimeout .
Le moteur de reconnaissance détecte la parole, mais ne trouve aucune correspondance dans ses objets chargés et activés Grammar .

Pour effectuer une reconnaissance synchrone, utilisez l’une des Recognize méthodes .

Voir aussi

S’applique à

Partager via

SpeechRecognitionEngine.RecognizeAsync Méthode

Définition

Surcharges

Remarques

RecognizeAsync()

Exemples

Remarques

Voir aussi

S’applique à

RecognizeAsync(RecognizeMode)

Paramètres

Exemples

Remarques

Voir aussi

S’applique à

Ressources supplémentaires