SpeechRecognitionEngine.RecognizeAsyncCancel Metoda

Definicja

Namespace:

System.Speech.Recognition

Montaż:

System.Speech.dll

Pakiet:

System.Speech v10.0.1

Źródło:

SpeechRecognitionEngine.cs

Kończy rozpoznawanie asynchroniczne bez oczekiwania na ukończenie bieżącej operacji rozpoznawania.

public:
 void RecognizeAsyncCancel();

public void RecognizeAsyncCancel();

member this.RecognizeAsyncCancel : unit -> unit

Public Sub RecognizeAsyncCancel ()

Przykłady

W poniższym przykładzie pokazano część aplikacji konsolowej, która demonstruje użycie RecognizeAsyncCancel metody . Przykład tworzy i ładuje gramatykę rozpoznawania mowy, inicjuje ciągłą operację rozpoznawania asynchronicznego, a następnie wstrzymuje 2 sekundy, zanim anuluje operację. Rozpoznawanie odbiera dane wejściowe z pliku c:\temp\audioinput\sample.wav. Programy obsługi zdarzeń są uwzględniane w celu zademonstrowania zdarzeń zgłaszanych przez aparat rozpoznawania podczas operacji.

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 and load a dictation grammar.
        Grammar dictation = new DictationGrammar();
        dictation.Name = "Dictation Grammar";

        recognizer.LoadGrammar(dictation);

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

        // Begin asynchronous recognition from pre-recorded input.
        recognizer.SetInputToWaveFile(@"c:\temp\audioinput\sample.wav");

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

        // Wait 2 seconds and then cancel the recognition operation.
        Thread.Sleep(TimeSpan.FromSeconds(2));
        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.Cancelled)
      {
        Console.WriteLine(" - asynchronous operation canceled.");
      }
      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);
      }
      else
      {
        Console.WriteLine(" - No result.");
      }

      completed = true;
    }
  }
}

Uwagi

Ta metoda natychmiast finalizuje rozpoznawanie asynchroniczne. Jeśli bieżąca operacja rozpoznawania asynchronicznego odbiera dane wejściowe, dane wejściowe są obcinane, a operacja kończy się z istniejącymi danymi wejściowymi. Aparat rozpoznawania zgłasza RecognizeCompleted zdarzenie lub EmulateRecognizeCompleted po anulowaniu operacji asynchronicznej i ustawia Cancelled właściwość obiektu RecognizeCompletedEventArgs na true. Ta metoda anuluje operacje asynchroniczne inicjowane przez RecognizeAsync metody i EmulateRecognizeAsync .

Aby zatrzymać rozpoznawanie asynchroniczne bez obcinania danych wejściowych, użyj RecognizeAsyncStop metody .

Zobacz także

• EmulateRecognizeAsync(String)
• RecognizeAsync()
• RecognizeAsyncStop()
• RecognizeCompleted
• EmulateRecognizeCompleted