Partager via

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

Les objets dynamiques exposent des membres tels que des propriétés et des méthodes au moment de l’exécution, au lieu du moment de la compilation. Les objets dynamiques vous permettent de créer des objets pour travailler avec des structures qui ne correspondent pas à un type statique ou à un format. 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’éléments de balisage HTML et d’attributs 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. Une méthode courante pour référencer un attribut d’un élément HTML consiste à passer le nom de l’attribut à la GetProperty méthode de l’élément. Pour référencer l’attribut id de l’élément <div id="Div1">HTML, 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 en tant que divElement.id.

Les objets dynamiques fournissent également un accès pratique aux langages dynamiques tels que 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 à l'aide des classes 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 également créer votre propre type qui hérite de la DynamicObject classe. Vous pouvez ensuite remplacer 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éez un objet personnalisé qui expose dynamiquement le contenu d’un fichier texte en tant que propriétés d’un objet.
  • Créez un projet qui utilise une IronPython bibliothèque.

Conditions préalables

Remarque

Votre ordinateur peut afficher différents noms ou emplacements pour certains des éléments de l’interface utilisateur Visual Studio dans les instructions suivantes. L’édition Visual Studio que vous avez et les paramètres que vous utilisez déterminent ces éléments. Pour plus d’informations, consultez Personnaliser 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 l’appel de code spécifie dynamicFile.Sample, la classe dynamique retourne une liste générique de chaînes qui contient toutes les lignes du fichier commençant par « Sample ». La recherche respecte la casse. La classe dynamique prend également en charge deux arguments facultatifs. Le premier argument est une valeur d’énumération d’option de recherche qui spécifie que la classe dynamique doit rechercher des correspondances au début de la ligne, à la fin de la ligne ou n’importe où dans la ligne. Le deuxième argument spécifie que la classe dynamique doit découper les espaces de début et de fin de chaque ligne avant de rechercher. Par exemple, si l’appel de code spécifie dynamicFile.Sample(StringSearchOption.Contains), la classe dynamique recherche « Sample » n’importe où dans une ligne. Si l’appel de code spécifie dynamicFile.Sample(StringSearchOption.StartsWith, false), la classe dynamique recherche « Sample » au début de chaque ligne et ne supprime pas les espaces de début et de fin. Le comportement par défaut de la classe dynamique consiste à rechercher une correspondance au début de chaque ligne et à supprimer les espaces de début et de fin.

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#, sélectionnez Application console, puis Sélectionnez Suivant. Dans la boîte de dialogue Configurer votre nouveau projet , entrez DynamicSample le nom du 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 solutions, cliquez avec le bouton droit sur le projet DynamicSample, puis sélectionnez Ajouter> uneclasse. 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 une énumération pour déterminer les critères de recherche. Avant la déclaration de classe, ajoutez la définition d’énumération suivante.

public enum StringSearchOption
{
    StartsWith,
    Contains,
    EndsWith
}

Mettez à jour l’instruction de classe pour hériter de la DynamicObject classe, comme illustré dans l’exemple de code suivant.

class ReadOnlyFile : DynamicObject

Ajoutez le code suivant à la ReadOnlyFile classe pour définir un champ privé pour le chemin d’accès du fichier et un constructeur pour la ReadOnlyFile classe.

// 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 suivante GetPropertyValue à la ReadOnlyFile classe. La GetPropertyValue méthode prend, comme entrée, critères de recherche et retourne les lignes d’un fichier texte qui correspondent à ces critères de recherche. Les méthodes dynamiques fournies par la ReadOnlyFile classe appellent la GetPropertyValue méthode 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 GetPropertyValue méthode, ajoutez le code suivant pour remplacer la TryGetMember méthode de la DynamicObject classe. La TryGetMember méthode est appelée lorsqu’un membre d’une classe dynamique est demandé et qu’aucun argument n’est spécifié. L’argument binder contient des informations sur le membre référencé et l’argument result fait référence au résultat retourné pour le membre spécifié. La TryGetMember méthode retourne une valeur booléenne qui retourne true si le membre demandé existe ; sinon, elle retourne 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 TryGetMember méthode, ajoutez le code suivant pour remplacer la TryInvokeMember méthode de la DynamicObject classe. La TryInvokeMember méthode est appelée lorsqu’un membre d’une classe dynamique est demandé avec des arguments. L’argument binder contient des informations sur le membre référencé et l’argument result fait référence au résultat retourné pour le membre spécifié. L’argument args contient un tableau des arguments passés au membre. La TryInvokeMember méthode retourne une valeur booléenne qui retourne true si le membre demandé existe ; sinon, elle retourne false.

La version personnalisée de la TryInvokeMember méthode s’attend à ce que le premier argument soit une valeur de l’énumération StringSearchOption que vous avez définie à l’étape précédente. La TryInvokeMember méthode s’attend à ce que le deuxième argument soit une valeur booléenne. Si un ou les deux arguments sont des valeurs valides, ils sont passés à la GetPropertyValue méthode 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 solutions, cliquez avec le bouton 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 . Laissez 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 Main procédure pour créer une instance de la ReadOnlyFile classe 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 langages dynamiques

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#, sélectionnez Application console, puis Sélectionnez Suivant. Dans la boîte de dialogue Configurer votre nouveau projet , entrez DynamicIronPythonSample le nom du 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 des bibliothèques IronPython, ainsi que 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 Microsoft.Scripting.Hosting.ScriptRuntime objet 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.");

Après avoir chargé le module random.py, ajoutez le code suivant pour créer un tableau d’entiers. Le tableau est passé à la shuffle méthode du module random.py, qui trie de façon aléatoire 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