Procédure pas-à-pas : création et utilisation d’objets dynamiques en C#

  • Article

Les objets dynamiques exposent des membres tels que les propriétés et les méthodes au moment de l’exécution et non lors de la compilation. Les objets dynamiques vous permettent de créer des objets utilisables avec des structures qui ne correspondent pas à un type ou un format statique. Par exemple, vous pouvez utiliser un objet dynamique pour référencer le modèle DOM (Document Object Model) HTML, qui peut contenir n’importe quelle combinaison d’attributs et d’éléments de balisage HTML valides. Étant donné que chaque document HTML est unique, les membres d’un document HTML particulier sont déterminés au moment de l’exécution. L’une des méthodes courantes pour référencer un attribut d’un élément HTML consiste à passer le nom de l’attribut à la méthode GetProperty de l’élément. Pour référencer l’attribut id de l’élément HTML <div id="Div1">, vous obtenez d’abord une référence à l’élément <div>, puis utilisez divElement.GetProperty("id"). Si vous utilisez un objet dynamique, vous pouvez référencer l’attribut id comme divElement.id.

Les objets dynamiques permettent également d’accéder facilement aux langages dynamiques comme IronPython et IronRuby. Vous pouvez utiliser un objet dynamique pour faire référence à un script dynamique interprété au moment de l’exécution.

Vous référencez un objet dynamique à l’aide de la liaison tardive. Vous spécifiez le type d’un objet à liaison tardive en tant que dynamic. Pour plus d’informations, consultez dynamique.

Vous pouvez créer des objets dynamiques personnalisés en utilisant les classes contenues dans l’espace de noms System.Dynamic. Par exemple, vous pouvez créer un ExpandoObject et spécifier les membres de cet objet au moment de l’exécution. Vous pouvez aussi créer votre propre type qui hérite de la classe DynamicObject. Vous pouvez ensuite substituer les membres de la classe DynamicObject pour fournir des fonctionnalités dynamiques au moment de l’exécution.

Cet article contient deux procédures pas à pas indépendantes :

  • Créer un objet personnalisé qui expose dynamiquement le contenu d’un fichier texte comme propriétés d’un objet.
  • Créer un projet qui utilise une bibliothèque IronPython.

Prérequis

Notes

Il est possible que pour certains des éléments de l'interface utilisateur de Visual Studio, votre ordinateur affiche des noms ou des emplacements différents de ceux indiqués dans les instructions suivantes. L'édition de Visual Studio dont vous disposez et les paramètres que vous utilisez déterminent ces éléments. Pour plus d’informations, consultez Personnalisation de l’IDE.

Créer un objet dynamique personnalisé

La première procédure pas à pas définit un objet dynamique personnalisé qui recherche le contenu d’un fichier texte. Une propriété dynamique spécifie le texte à rechercher. Par exemple, si le code appelant spécifie dynamicFile.Sample, la classe dynamique retourne une liste générique de chaînes qui contient toutes les lignes du fichier qui commencent par « Sample ». La recherche respecte la casse. La classe dynamique prend également en charge deux arguments facultatifs. Le premier argument est une valeur enum de l’option de recherche qui spécifie que la classe dynamique doit rechercher des correspondances en début de ligne, en fin de ligne, ou n’importe où dans la ligne. Le deuxième argument spécifie que la classe dynamique doit supprimer des espaces à gauche et à droite dans chaque ligne avant d’effectuer la recherche. Par exemple, si le code appelant spécifie dynamicFile.Sample(StringSearchOption.Contains), la classe dynamique recherche le terme « Sample » n’importe où dans une ligne. Si le code appelant spécifie dynamicFile.Sample(StringSearchOption.StartsWith, false), la classe dynamique recherche le terme « Sample » au début de chaque ligne et ne supprime ni les espaces à droite, ni les espaces à gauche. Le comportement par défaut de la classe dynamique consiste à rechercher une correspondance au début de chaque ligne et à supprimer les espaces à gauche et à droite.

Créer une classe dynamique personnalisée

Démarrez Visual Studio. Sélectionnez Créer un projet. Dans la boîte de dialogue Créer un projet, sélectionnez C#, Application console, puis Suivant. Dans la boîte de dialogue Configurer votre nouveau projet, entrez DynamicSample pour le Nom de projet, puis sélectionnez Suivant. Dans la boîte de dialogue Informations supplémentaires, sélectionnez .NET 7.0 (Actif) pour le Framework cible, puis sélectionnez Créer. Dans l’Explorateur de solutionsfaites un clic droit sur le projet DynamicSample, puis sélectionnez Ajouter>une Classe. Dans la zone Nom, tapez ReadOnlyFile, puis sélectionnez Ajouter. En haut du fichier ReadOnlyFile.cs ou ReadOnlyFile.vb, ajoutez le code suivant pour importer les espaces de noms System.IO et System.Dynamic.

using System.IO;
using System.Dynamic;

L’objet dynamique personnalisé utilise un enum pour déterminer les critères de recherche. Avant l’instruction de classe, ajoutez la définition d’enum suivante.

public enum StringSearchOption
{
    StartsWith,
    Contains,
    EndsWith
}

Mettez à jour l’instruction de classe de façon à hériter de la classe DynamicObject, comme indiqué dans l’exemple de code suivant.

class ReadOnlyFile : DynamicObject

Ajoutez le code suivant à la classe ReadOnlyFile afin de définir un champ privé pour le chemin du fichier et un constructeur pour la classe ReadOnlyFile.

// Store the path to the file and the initial line count value.
private string p_filePath;

// Public constructor. Verify that file exists and store the path in
// the private variable.
public ReadOnlyFile(string filePath)
{
    if (!File.Exists(filePath))
    {
        throw new Exception("File path does not exist.");
    }

    p_filePath = filePath;
}
  1. Ajoutez la méthode GetPropertyValue suivante à la classe ReadOnlyFile. La méthode GetPropertyValue prend les critères de recherche comme paramètre d’entrée et retourne les lignes d’un fichier texte qui correspondent aux critères de recherche. Les méthodes dynamiques fournies par la classe ReadOnlyFile appellent la méthode GetPropertyValue pour récupérer leurs résultats respectifs.
public List<string> GetPropertyValue(string propertyName,
                                     StringSearchOption StringSearchOption = StringSearchOption.StartsWith,
                                     bool trimSpaces = true)
{
    StreamReader sr = null;
    List<string> results = new List<string>();
    string line = "";
    string testLine = "";

    try
    {
        sr = new StreamReader(p_filePath);

        while (!sr.EndOfStream)
        {
            line = sr.ReadLine();

            // Perform a case-insensitive search by using the specified search options.
            testLine = line.ToUpper();
            if (trimSpaces) { testLine = testLine.Trim(); }

            switch (StringSearchOption)
            {
                case StringSearchOption.StartsWith:
                    if (testLine.StartsWith(propertyName.ToUpper())) { results.Add(line); }
                    break;
                case StringSearchOption.Contains:
                    if (testLine.Contains(propertyName.ToUpper())) { results.Add(line); }
                    break;
                case StringSearchOption.EndsWith:
                    if (testLine.EndsWith(propertyName.ToUpper())) { results.Add(line); }
                    break;
            }
        }
    }
    catch
    {
        // Trap any exception that occurs in reading the file and return null.
        results = null;
    }
    finally
    {
        if (sr != null) {sr.Close();}
    }

    return results;
}

Après la méthode GetPropertyValue, ajoutez le code suivant pour substituer la méthode TryGetMember de la classe DynamicObject. La méthode TryGetMember est appelée quand un membre d’une classe dynamique est demandé et qu’aucun argument n’est spécifié. L’argument binder contient les informations relatives au membre référencé et l’argument result référence le résultat retourné pour le membre spécifié. La méthode TryGetMember retourne une valeur booléenne qui retourne true si le membre demandé existe ; sinon, elle retourne la valeur false.

// Implement the TryGetMember method of the DynamicObject class for dynamic member calls.
public override bool TryGetMember(GetMemberBinder binder,
                                  out object result)
{
    result = GetPropertyValue(binder.Name);
    return result == null ? false : true;
}

Après la méthode TryGetMember, ajoutez le code suivant pour substituer la méthode TryInvokeMember de la classe DynamicObject. La méthode TryInvokeMember est appelée quand un membre d’une classe dynamique est demandé avec des arguments. L’argument binder contient les informations relatives au membre référencé et l’argument result référence le résultat retourné pour le membre spécifié. L’argument args contient un tableau des arguments passés au membre. La méthode TryInvokeMember retourne une valeur booléenne qui retourne true si le membre demandé existe ; sinon, elle retourne la valeur false.

La version personnalisée de la méthode TryInvokeMember s’attend à ce que le premier argument soit une valeur de l’enum StringSearchOption que vous avez défini dans une étape précédente. La méthode TryInvokeMember s’attend à ce que le deuxième argument soit une valeur booléenne. Si l’un des arguments ou les deux arguments sont des valeurs valides, ils sont passés à la méthode GetPropertyValue pour récupérer les résultats.

// Implement the TryInvokeMember method of the DynamicObject class for
// dynamic member calls that have arguments.
public override bool TryInvokeMember(InvokeMemberBinder binder,
                                     object[] args,
                                     out object result)
{
    StringSearchOption StringSearchOption = StringSearchOption.StartsWith;
    bool trimSpaces = true;

    try
    {
        if (args.Length > 0) { StringSearchOption = (StringSearchOption)args[0]; }
    }
    catch
    {
        throw new ArgumentException("StringSearchOption argument must be a StringSearchOption enum value.");
    }

    try
    {
        if (args.Length > 1) { trimSpaces = (bool)args[1]; }
    }
    catch
    {
        throw new ArgumentException("trimSpaces argument must be a Boolean value.");
    }

    result = GetPropertyValue(binder.Name, StringSearchOption, trimSpaces);

    return result == null ? false : true;
}

Enregistrez et fermez le fichier.

Créer un exemple de fichier texte

Dans l’Explorateur de solutionsfaites un clic droit sur le projet DynamicSample, puis sélectionnez Ajouter>un Nouvel élément. Dans le volet Modèles installés, sélectionnez Général, puis sélectionnez le modèle Fichier texte. Conservez le nom par défaut de TextFile1.txt dans la zone Nom, puis sélectionnez Ajouter. Copiez le texte suivant dans le fichier TextFile1.txt.

List of customers and suppliers

Supplier: Lucerne Publishing (https://www.lucernepublishing.com/)
Customer: Preston, Chris
Customer: Hines, Patrick
Customer: Cameron, Maria
Supplier: Graphic Design Institute (https://www.graphicdesigninstitute.com/)
Supplier: Fabrikam, Inc. (https://www.fabrikam.com/)
Customer: Seubert, Roxanne
Supplier: Proseware, Inc. (http://www.proseware.com/)
Customer: Adolphi, Stephan
Customer: Koch, Paul

Enregistrez et fermez le fichier.

Créer un exemple d’application qui utilise l’objet dynamique personnalisé

Dans l'Explorateur de solutions, double-cliquez sur le fichier Program.cs. Ajoutez le code suivant à la procédure Main pour créer une instance de la classe ReadOnlyFile pour le fichier TextFile1.txt. Le code utilise la liaison tardive pour appeler des membres dynamiques et récupérer des lignes de texte qui contiennent la chaîne « Customer ».

dynamic rFile = new ReadOnlyFile(@"..\..\..\TextFile1.txt");
foreach (string line in rFile.Customer)
{
    Console.WriteLine(line);
}
Console.WriteLine("----------------------------");
foreach (string line in rFile.Customer(StringSearchOption.Contains, true))
{
    Console.WriteLine(line);
}

Enregistrez le fichier et appuyez sur Ctrl+F5 pour générer et exécuter l’application.

Appeler une bibliothèque de langage dynamique

La procédure pas-à-pas suivante crée un projet qui accède à une bibliothèque écrite dans le langage dynamique IronPython.

Pour créer une classe dynamique personnalisée

Dans Visual Studio, sélectionnez Fichier>Nouveau>Projet. Dans la boîte de dialogue Créer un projet, sélectionnez C#, Application console, puis Suivant. Dans la boîte de dialogue Configurer votre nouveau projet, entrez DynamicIronPythonSample pour le Nom de projet, puis sélectionnez Suivant. Dans la boîte de dialogue Informations supplémentaires, sélectionnez .NET 7.0 (Actif) pour le Framework cible, puis sélectionnez Créer. Installez le package NuGet IronPython. Modifiez le fichier Program.cs. En haut du fichier, ajoutez le code suivant pour importer les espaces de noms Microsoft.Scripting.Hosting et IronPython.Hosting à partir des bibliothèques IronPython et de l’espace de noms System.Linq.

using System.Linq;
using Microsoft.Scripting.Hosting;
using IronPython.Hosting;

Dans la méthode Main, ajoutez le code suivant pour créer un objet Microsoft.Scripting.Hosting.ScriptRuntime pour héberger les bibliothèques IronPython. L’objet ScriptRuntime charge le module de bibliothèque IronPython random.py.

// Set the current directory to the IronPython libraries.
System.IO.Directory.SetCurrentDirectory(
   Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles) +
   @"\IronPython 2.7\Lib");

// Create an instance of the random.py IronPython library.
Console.WriteLine("Loading random.py");
ScriptRuntime py = Python.CreateRuntime();
dynamic random = py.UseFile("random.py");
Console.WriteLine("random.py loaded.");

Une fois que le code a chargé le module random.py, ajoutez le code suivant pour créer un tableau d’entiers. Le tableau est passé à la méthode shuffle du module random.py, qui trie aléatoirement les valeurs dans le tableau.

// Initialize an enumerable set of integers.
int[] items = Enumerable.Range(1, 7).ToArray();

// Randomly shuffle the array of integers by using IronPython.
for (int i = 0; i < 5; i++)
{
    random.shuffle(items);
    foreach (int item in items)
    {
        Console.WriteLine(item);
    }
    Console.WriteLine("-------------------");
}

Enregistrez le fichier et appuyez sur Ctrl+F5 pour générer et exécuter l’application.

Voir aussi