SrgsToken.Pronunciation Eigenschaft

Definition

Namespace:

System.Speech.Recognition.SrgsGrammar

Assembly:

System.Speech.dll

Paket:

System.Speech v9.0.0-preview.3.24172.9

Quelle:

SrgsToken.cs

Ruft die Zeichenfolge ab, bzw. legt sie fest, welche die Aussprache für den Token definiert.

public:
 property System::String ^ Pronunciation { System::String ^ get(); void set(System::String ^ value); };

public string Pronunciation { get; set; }

member this.Pronunciation : string with get, set

Public Property Pronunciation As String

Eigenschaftswert

String

Gibt eine Zeichenfolge zurück, die Phone des Lautalphabets enthält, das in PhoneticAlphabet angegeben wird.

Ausnahmen

ArgumentNullException

Es wird versucht, Pronunciation auf null festzulegen.

ArgumentOutOfRangeException

Es wird versucht, Pronunciation eine leere Zeichenfolge zuzuweisen.

Beispiele

Die Grammatik im folgenden Beispiel enthält Slangwörter und hat auch ein ungewöhnliches Wort: "whatchamacallit". Das Hinzufügen einer benutzerdefinierten Inline-Aussprache mithilfe der Pronunciation -Eigenschaft der SrgsToken -Klasse kann die Genauigkeit der Erkennung für das Wort "whatchamacallit" sowie für den gesamten Ausdruck verbessern, der es enthält. Im Beispiel werden Telefone aus dem Microsoft Universal Phone Set (USV) verwendet, um die benutzerdefinierte Aussprache zu definieren.

using System;
using System.Speech.Recognition;
using System.Speech.Recognition.SrgsGrammar;

namespace SampleRecognition
{
  class Program
  {
    static void Main(string[] args)

    // Initialize an instance of the in-process recognizer.
    {
      using (SpeechRecognitionEngine recognizer =
         new SpeechRecognitionEngine(new System.Globalization.CultureInfo("en-US")))
      {

        // Build the SrgsOneOf objects with alternative choices for the slang phrase.
        SrgsOneOf gimme = new SrgsOneOf(
          new string[] { "give me", "gimme", "hand me", "ha'me" });
        SrgsOneOf the = new SrgsOneOf(new string[] { "the", "duh" });

        // Build the one-of element that contains the pronunciation.
        SrgsItem thing = new SrgsItem("thingamajig");
        SrgsItem whatcha = new SrgsItem();
        SrgsToken callit = new SrgsToken("whatchamacallit");
        callit.Pronunciation = "W AE T CH AE M AE K AA L IH T";
        whatcha.Add(callit);
        SrgsOneOf what = new SrgsOneOf(new SrgsItem[] {thing, whatcha});

        // Create the rule from the SrgsOneOf objects.
        SrgsRule slangRule = new SrgsRule("slang", gimme, the, what);

        // Build an SrgsDocument object from the rule and set the phonetic alphabet.
        SrgsDocument tokenPron = new SrgsDocument(slangRule);
        tokenPron.PhoneticAlphabet = SrgsPhoneticAlphabet.Ups;

        // Create a Grammar object from the SrgsDocument and load it to the recognizer.
        Grammar g_Slang = new Grammar(tokenPron);
        g_Slang.Name = ("Slang Pronunciation");
        recognizer.LoadGrammarAsync(g_Slang);

        // Configure recognizer input.
        recognizer.SetInputToDefaultAudioDevice();

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

        // Start asynchronous recognition.
        recognizer.RecognizeAsync();
        Console.WriteLine("Starting asynchronous recognition...");

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

    // Handle the SpeechRecognized event.
    static void recognizer_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
    {
      Console.WriteLine("Recognized phrase: " + e.Result.Text);
      Console.WriteLine("Confidence: " + e.Result.Confidence);
      Console.WriteLine("  Word summary: ");
      foreach (RecognizedWordUnit word in e.Result.Words)
      {
        Console.WriteLine(
          "    Lexical form ({1})" +
          " Pronunciation ({0})" +
          " Confidence ({2})",
          word.Pronunciation, word.LexicalForm, word.Confidence);
      }
    }
  }
}

Hinweise

Telefone sind Buchstaben oder Symbole, die die Geräusche der Sprache beschreiben. System.Speech unterstützt drei phonetische Alphabete zum Angeben benutzerdefinierter Aussprachen: die Universal Phone Set (UPS), die Sprach-API (SAPI) Phone set und das International Phonetic Alphabet (IPA). Die in Pronunciation angegebenen Telefone müssen mit dem in PhoneticAlphabetangegebenen phonetischen Alphabet übereinstimmen. Weitere Informationen finden Sie unter Lexicons und Phonetische Alphabete .

Die in Pronunciation angegebenen Telefone geben an, wie der Inhalt von Text für eine erfolgreiche Erkennung ausgesprochen werden soll. Die Spracherkennungs-Engine verwendet die in Pronunciation angegebene Aussprache, um die Spracheingabe abzugleichen und gibt die im Erkennungsergebnis enthaltene Zeichenfolge zurück Text .

Wenn die Telefone nicht durch Leerzeichen getrennt sind oder die angegebene Zeichenfolge ein unbekanntes Telefon enthält, erkennt die Erkennungs-Engine die angegebene Aussprache nicht als gültige Aussprache des Worts, das in Textenthalten ist.

Aussprachen, die in Pronunciation angegeben sind, haben Vorrang vor Aussprachen, die in Lexikas angegeben sind, die einer Grammatik oder einer Erkennungs-Engine zugeordnet sind. Außerdem gilt die Aussprache in der Pronunciation -Eigenschaft nur für das einzelne Vorkommen des Worts oder Ausdrucks, das in Textenthalten ist.

Weitere Informationen

• Lexika und Phonetische Alphabete