SpeechRecognizer.LoadGrammarCompleted Gebeurtenis

public:
 event EventHandler<System::Speech::Recognition::LoadGrammarCompletedEventArgs ^> ^ LoadGrammarCompleted;

public event EventHandler<System.Speech.Recognition.LoadGrammarCompletedEventArgs> LoadGrammarCompleted;

member this.LoadGrammarCompleted : EventHandler<System.Speech.Recognition.LoadGrammarCompletedEventArgs> 

Public Custom Event LoadGrammarCompleted As EventHandler(Of LoadGrammarCompletedEventArgs) 

Public Event LoadGrammarCompleted As EventHandler(Of LoadGrammarCompletedEventArgs) 

Gebeurtenistype

Voorbeelden

In het volgende voorbeeld wordt een gedeelde spraakherkenning gemaakt en vervolgens twee typen grammatica's gemaakt voor het herkennen van specifieke woorden en voor het accepteren van vrije dicteren. In het voorbeeld worden alle gemaakte grammatica's asynchroon geladen naar de recognizer. Handlers voor de recognizer LoadGrammarCompleted en SpeechRecognized gebeurtenissen schrijven naar de console de naam van de grammatica die is gebruikt om respectievelijk de herkenning en de tekst van het herkenningsresultaat uit te voeren.

using System;
using System.Speech.Recognition;

namespace SampleRecognition
{
  class Program
  {
    private static SpeechRecognizer recognizer;
    public static void Main(string[] args)
    {

      // Initialize a shared speech recognition engine.
      recognizer = new SpeechRecognizer();

        // Add a handler for the LoadGrammarCompleted event.
        recognizer.LoadGrammarCompleted +=
          new EventHandler<LoadGrammarCompletedEventArgs>(recognizer_LoadGrammarCompleted);

        // Add a handler for the SpeechRecognized event.
        recognizer.SpeechRecognized +=
          new EventHandler<SpeechRecognizedEventArgs>(recognizer_SpeechRecognized);

        // Add a handler for the StateChanged event.
        recognizer.StateChanged +=
          new EventHandler<StateChangedEventArgs>(recognizer_StateChanged);

        // Create "yesno" grammar.
        Choices yesChoices = new Choices(new string[] { "yes", "yup", "yeah}" });
        SemanticResultValue yesValue =
            new SemanticResultValue(yesChoices, (bool)true);
        Choices noChoices = new Choices(new string[] { "no", "nope", "neah" });
        SemanticResultValue noValue =
            new SemanticResultValue(noChoices, (bool)false);
        SemanticResultKey yesNoKey =
            new SemanticResultKey("yesno", new Choices(new GrammarBuilder[] { yesValue, noValue }));
        Grammar yesnoGrammar = new Grammar(yesNoKey);
        yesnoGrammar.Name = "yesNo";

        // Create "done" grammar.
        Grammar doneGrammar =
          new Grammar(new Choices(new string[] { "done", "exit", "quit", "stop" }));
        doneGrammar.Name = "Done";

        // Create dictation grammar.
        Grammar dictation = new DictationGrammar();
        dictation.Name = "Dictation";

        // Load grammars to the recognizer.
        recognizer.LoadGrammarAsync(yesnoGrammar);
        recognizer.LoadGrammarAsync(doneGrammar);
        recognizer.LoadGrammarAsync(dictation);

        // Keep the console window open.
        Console.ReadLine();
      }

    // Handle the SpeechRecognized event.
    static void recognizer_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
    {
      Console.WriteLine("Grammar({0}): {1}", e.Result.Grammar.Name, e.Result.Text);

      // Add event handler code here.
    }

    // Handle the LoadGrammarCompleted event.
    static void recognizer_LoadGrammarCompleted(object sender, LoadGrammarCompletedEventArgs e)
    {
      string grammarName = e.Grammar.Name;
      bool grammarLoaded = e.Grammar.Loaded;

      if (e.Error != null)
      {
        Console.WriteLine("LoadGrammar for {0} failed with a {1}.",
        grammarName, e.Error.GetType().Name);

        // Add exception handling code here.
      }

      Console.WriteLine("Grammar {0} {1} loaded.",
      grammarName, (grammarLoaded) ? "is" : "is not");
    }

    // Put the shared speech recognizer into "listening" mode.
    static void recognizer_StateChanged(object sender, StateChangedEventArgs e)
    {
      if (e.RecognizerState != RecognizerState.Stopped)
      {
        recognizer.EmulateRecognizeAsync("Start listening");
      }
    }
  }
}

Opmerkingen

De methode van LoadGrammarAsync recognizer initieert een asynchrone bewerking. De recognizer genereert de LoadGrammarCompleted gebeurtenis wanneer deze de bewerking voltooit. Als u het Grammar object wilt ophalen dat door de recognizer is geladen, gebruikt u de Grammar eigenschap van de gekoppelde LoadGrammarCompletedEventArgs. Gebruik de eigenschap van Grammars de recognizer om de huidige Grammar objecten op te halen die door de recognizer zijn geladen.

Wanneer u een gemachtigde voor een LoadGrammarCompleted gebeurtenis maakt, identificeert u de methode waarmee de gebeurtenis wordt verwerkt. Als u de gebeurtenis wilt koppelen aan uw gebeurtenis-handler, voegt u een exemplaar van de gemachtigde toe aan de gebeurtenis. De gebeurtenis-handler wordt aangeroepen wanneer de gebeurtenis plaatsvindt, tenzij u de gemachtigde verwijdert. Zie Gebeurtenissen en gemachtigden voor meer informatie over gedelegeerden voor gebeurtenissen en gemachtigden.

Zie ook

• Grammar
• LoadGrammarCompletedEventArgs
• Grammars
• LoadGrammarAsync(Grammar)