SemanticValue Classe

Définition

Espace de noms:

System.Speech.Recognition

Assembly:

System.Speech.dll

Paquet:

System.Speech v8.0.0

Source:

SemanticValue.cs

Représente l’organisation sémantique d’une expression reconnue.

public ref class SemanticValue sealed : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<System::String ^, System::Speech::Recognition::SemanticValue ^>>, System::Collections::Generic::IDictionary<System::String ^, System::Speech::Recognition::SemanticValue ^>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<System::String ^, System::Speech::Recognition::SemanticValue ^>>

[System.Serializable]
public sealed class SemanticValue : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string,System.Speech.Recognition.SemanticValue>>, System.Collections.Generic.IDictionary<string,System.Speech.Recognition.SemanticValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,System.Speech.Recognition.SemanticValue>>

[<System.Serializable>]
type SemanticValue = class
    interface IDictionary<string, SemanticValue>
    interface ICollection<KeyValuePair<string, SemanticValue>>
    interface seq<KeyValuePair<string, SemanticValue>>
    interface IEnumerable

Public NotInheritable Class SemanticValue
Implements ICollection(Of KeyValuePair(Of String, SemanticValue)), IDictionary(Of String, SemanticValue), IEnumerable(Of KeyValuePair(Of String, SemanticValue))

Héritage

Object

SemanticValue

Attributs

SerializableAttribute

Implémente

ICollection<KeyValuePair<String,SemanticValue>> ICollection<KeyValuePair<TKey,TValue>> IDictionary<String,SemanticValue> IEnumerable<KeyValuePair<String,SemanticValue>> IEnumerable<KeyValuePair<TKey,TValue>> IEnumerable<T> IEnumerable

Exemples

L’exemple suivant montre un gestionnaire pour un SpeechRecognized événement conçu pour gérer les commandes afin de modifier la couleur de premier plan et d’arrière-plan.

Le gestionnaire identifie les expressions reconnues qui n’ont aucune structure sémantique sous-jacente en détectant un Count de zéro et un Value de null. Cette sortie de reconnaissance est ensuite traitée directement en analysant le texte brut.

Dans d’autres cas, le gestionnaire utilise des clés pour obtenir les composants RVB d’un nom de couleur, pour déterminer si la commande modifie le premier plan ou l’arrière-plan, ou pour indiquer qu’aucune clé valide n’a été trouvée.

newGrammar.SpeechRecognized +=  
  delegate(object sender, SpeechRecognizedEventArgs eventArgs)   
  {  

    // Retrieve the value of the semantic property.  
    bool changeBackGround = true;  
    string errorString = "";  
    SemanticValue semantics = eventArgs.Result.Semantics;  

    Color newColor = Color.Empty;  

    try   
    {  
      if (semantics.Count == 0 && semantics.Value==null)  
      {  
        // Signifies recognition by a grammar with no semantics.  
        // Parse the string, assuming that the last word is color,  
        // and search for "background" or "foreground" in the input.  
        if (eventArgs.Result.Text.Contains("foreground"))   
        {  
          changeBackGround = false;  
        }  
        string cName = eventArgs.Result.Words[eventArgs.Result.Words.Count - 1].Text;  
        newColor = Color.FromName(cName);  

      }  
      else if (semantics.ContainsKey("colorStringList") ^ semantics.ContainsKey("colorRGBValueList"))   
      {  

        // Determine whether to change background or foreground.  
        if (semantics.ContainsKey("applyChgToBackground"))   
        {  
          changeBackGround = semantics["applyChgToBackground"].Value is bool;  
        }  

        // Get the RGB color value.  
        if (semantics.ContainsKey("colorStringList"))   
        {  
          newColor = Color.FromName((string)semantics["colorStringList"].Value);  
        }  
        if (semantics.ContainsKey("colorRGBValueList"))   
        {  
          newColor = System.Drawing.Color.FromArgb((int)semantics["colorRGBValueList"].Value);  
        }  
      }  
      else   
      {  

        // Throw an exception if the semantics do not contain the keys we  
        // support.  
        throw(new Exception("Unsupported semantics keys found."));  
      }  
    }  

    catch (Exception exp)   
    {  
      MessageBox.Show(String.Format("Unable to process color semantics.:\n{0}\n", exp.Message));  
      return;  
    }  

    // Change colors, either foreground or background.  
    if (changeBackGround)   
    {  
      BackColor = newColor;  
      float Bright = BackColor.GetBrightness();  
      float Hue = BackColor.GetHue();  
      float Sat = BackColor.GetSaturation();  

      // Make sure that text is readable regardless of the background.  
      if (BackColor.GetBrightness() <= .50)   
      {  
        ForeColor = Color.White;  
      }  
      else   
      {  
        ForeColor = Color.Black;  
      }  
    }  
    else   
    {  
      ForeColor = newColor;  
      float Bright = ForeColor.GetBrightness();  
      float Hue = ForeColor.GetHue();  
      float Sat = ForeColor.GetSaturation();  

      // Make sure that text is readable regardless of Foreground.  
      if (ForeColor.GetBrightness() <= .50)   
      {  
        BackColor = Color.White;  
      }  
      else   
      {  
        BackColor = Color.Black;  
      }  
    }  
    return;  
  };  

Remarques

SemanticValue est l’objet principal qui implémente la technologie sémantique dans System.Speech. L’interprétation sémantique permet aux grammaires de définir des règles à utiliser par un moteur de reconnaissance pour interpréter correctement l’entrée audio. L’interprétation sémantique permet également aux moteurs de reconnaissance d’organiser leurs résultats afin qu’ils puissent être traités plus facilement, plutôt que de renvoyer uniquement des mots et des séquences de mots reconnus.

Par exemple, la sortie du moteur de reconnaissance « Remplacer l’arrière-plan en rouge » doit être analysée et interprétée par une application avant de pouvoir agir. Un Grammar objet peut spécifier une interprétation sémantique pour rendre le traitement plus clair en spécifiant que l’expression a deux sous-structures sémantiques, l’une pour sélectionner l’arrière-plan ou le premier plan (représentée par le texte « arrière-plan ») et l’autre pour sélectionner la couleur (représentée par le texte « rouge »).

System.Speech représente la sémantique d’une opération de reconnaissance dans une arborescence d’objets SemanticValue .

Chaque SemanticValue instance comprend les éléments suivants :

• , Objectaccessible au moyen de la Value propriété , utilisé pour la clé de la instance du SemanticValue.

• Mesure de la précision de l’analyse sémantique, retournée par la Confidence propriété .

• Collection de paires nom/valeur (KeyValuePair<TKey,TValue>) d’objets enfants, qui sont également SemanticValue des instances. Les nœuds enfants sont accessibles via l’implémentation SemanticValue d’une clé de IDictionary<TKey,TValue> recherche de chaîne et d’un SemanticValue instance, comme dans l’exemple suivant.

  foreach (KeyValuePair<String, SemanticValue> child in semantics)   
  {  
    Utils.CreateSemanticsTreeNodes(semanticsNode.Nodes, child.Value, child.Key);  
  }  
  

Les moteurs de reconnaissance basés sur System.Speech fournissent des instances valides de SemanticValue pour toutes les sorties de la reconnaissance, même pour les expressions sans structure sémantique explicite.

Le SemanticValue instance d’une expression est obtenu à l’aide de la Semantics propriété sur l’objet RecognizedPhrase (ou d’objets qui en héritent, tels que RecognitionResult).

SemanticValue les objets obtenus pour les expressions reconnues sans structure sémantique sont caractérisés par :

• Le manque d’enfants (Count est 0).

• La propriété Value a la valeur null.

• Niveau de confiance sémantique artificiel de 1.0 (retourné par Confidence).

En règle générale, les applications créent SemanticValue des instances indirectement, en les ajoutant à des objets à Grammar l’aide SemanticResultValue d’instances et SemanticResultKey , conjointement avec Choices des objets et GrammarBuilder .

La construction directe d’un SemanticValue instance est utile lors de la création de grammaires fortement typées.

SemanticValue implémente les IDictionary<TKey,TValue>interfaces , ICollection<T>et IEnumerable<T> .

Constructeurs

SemanticValue(Object)	Initialise une nouvelle instance de la classe SemanticValue et spécifie une valeur sémantique.
SemanticValue(String, Object, Single)	Initialise une nouvelle instance de la classe SemanticValue et spécifie une valeur sémantique, un nom de clé et un niveau de confiance.

Propriétés

Confidence	Retourne une mesure relative de la certitude quant à l'exactitude de l'analyse sémantique retournée à l'instance SemanticValue actuelle.
Count	Retourne le nombre d'objets SemanticValue enfants sous l'instance SemanticValue actuelle.
Item[String]	Retourne les instances enfants SemanticValue qui appartiennent au actuel SemanticValue.
Value	Propriété en lecture seule qui retourne les informations contenues dans la SemanticValueactuelle.

Méthodes

Contains(KeyValuePair<String,SemanticValue>)	Indique si la collection actuelle d'instance de SemanticValue contient une clé et une instance spécifiques de SemanticValue exprimées comme une paire clé/valeur.
ContainsKey(String)	Indique si la collection actuelle d'instance de SemanticValue contient une instance enfant de SemanticValue avec une chaîne clé donnée.
Equals(Object)	Détermine si un objet spécifié est un instance de SemanticValue et égal à la instance actuelle de SemanticValue.
GetHashCode()	Fournit un code de hachage pour un SemanticValue objet.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

ICollection<KeyValuePair<String,SemanticValue>>.Add(KeyValuePair<String,SemanticValue>)	Ajoute la clé et la SemanticValue spécifiées à la collection.
ICollection<KeyValuePair<String,SemanticValue>>.Clear()	Supprime toutes les paires clé-valeur de la collection.
ICollection<KeyValuePair<String,SemanticValue>>.CopyTo(KeyValuePair<String,SemanticValue>[], Int32)	Copie une paire clé/valeur à un emplacement spécifique dans un tableau cible.
ICollection<KeyValuePair<String,SemanticValue>>.IsReadOnly	Obtient une valeur qui indique si la collection est en lecture seule.
ICollection<KeyValuePair<String,SemanticValue>>.Remove(KeyValuePair<String,SemanticValue>)	Supprime la clé et le SemanticValue spécifiés de la collection.
IDictionary<String,SemanticValue>.Add(String, SemanticValue)	Ajoute la clé et la SemanticValue spécifiées au dictionnaire.
IDictionary<String,SemanticValue>.Keys	Obtient une collection qui contient les clés d'un dictionnaire de paires clé/valeur.
IDictionary<String,SemanticValue>.Remove(String)	Supprime la clé et le SemanticValue spécifiés du dictionnaire.
IDictionary<String,SemanticValue>.TryGetValue(String, SemanticValue)	Obtient le SemanticValue associé à la clé spécifiée.
IDictionary<String,SemanticValue>.Values	Obtient une collection qui contient les valeurs d'un dictionnaire de paires clé/valeur.
IEnumerable.GetEnumerator()	Retourne un énumérateur qui itère au sein d’une collection.
IEnumerable<KeyValuePair<String,SemanticValue>>.GetEnumerator()	Retourne un énumérateur qui itère au sein d’une collection.

Méthodes d’extension

Voir aussi

• SemanticResultValue
• SemanticResultKey