Classe System.Dynamic.ExpandoObject

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

La ExpandoObject classe vous permet d’ajouter et de supprimer des membres de ses instances au moment de l’exécution, ainsi que de définir et d’obtenir des valeurs de ces membres. Cette classe prend en charge la liaison dynamique, qui vous permet d’utiliser la syntaxe standard comme sampleObject.sampleMember au lieu d’une syntaxe plus complexe comme sampleObject.GetAttribute("sampleMember").

La ExpandoObject classe implémente l’interface IDynamicMetaObjectProviderDLR (Dynamic Language Runtime) standard, qui vous permet de partager des instances de la ExpandoObject classe entre les langages qui prennent en charge le modèle d’interopérabilité DLR. Par exemple, vous pouvez créer une instance de la ExpandoObject classe en C#, puis la passer à une fonction IronPython. Pour plus d’informations, consultez Vue d’ensemble du runtime de langage dynamique et présentation de ExpandoObject.

La ExpandoObject classe est une implémentation du concept d’objet dynamique qui permet d’obtenir, de définir et d’appeler des membres. Si vous souhaitez définir des types qui ont leur propre sémantique de répartition dynamique, utilisez la DynamicObject classe. Si vous souhaitez définir la façon dont les objets dynamiques participent au protocole d’interopérabilité et gèrent la mise en cache de distribution dynamique rapide DLR, créez votre propre implémentation de l’interface IDynamicMetaObjectProvider .

Créer une instance

En C#, pour activer la liaison tardive pour une instance de la ExpandoObject classe, vous devez utiliser le dynamic mot clé. Pour plus d’informations, consultez Utilisation du type dynamic.

Dans Visual Basic, les opérations dynamiques sont prises en charge par la liaison tardive. Pour plus d’informations, consultez Liaison anticipée et tardive (Visual Basic).

L’exemple de code suivant montre comment créer une instance de la ExpandoObject classe.

dynamic sampleObject = new ExpandoObject();

Dim sampleObject As Object = New ExpandoObject()

Ajouter des nouveaux membres

Vous pouvez ajouter des propriétés, des méthodes et des événements à des instances de la ExpandoObject classe.

L’exemple de code suivant montre comment ajouter une nouvelle propriété à une instance de la ExpandoObject classe.

sampleObject.test = "Dynamic Property";
Console.WriteLine(sampleObject.test);
Console.WriteLine(sampleObject.test.GetType());
// This code example produces the following output:
// Dynamic Property
// System.String

sampleObject.Test = "Dynamic Property"
Console.WriteLine(sampleObject.test)
Console.WriteLine(sampleObject.test.GetType())
' This code example produces the following output:
' Dynamic Property
' System.String

Les méthodes représentent des expressions lambda stockées en tant que délégués, qui peuvent être appelées lorsqu’elles sont nécessaires. L’exemple de code suivant montre comment ajouter une méthode qui incrémente une valeur de la propriété dynamique.

sampleObject.number = 10;
sampleObject.Increment = (Action)(() => { sampleObject.number++; });

// Before calling the Increment method.
Console.WriteLine(sampleObject.number);

sampleObject.Increment();

// After calling the Increment method.
Console.WriteLine(sampleObject.number);
// This code example produces the following output:
// 10
// 11

sampleObject.Number = 10
sampleObject.Increment = Function() sampleObject.Number + 1
' Before calling the Increment method.
Console.WriteLine(sampleObject.number)

sampleObject.Increment.Invoke()

' After calling the Increment method.
Console.WriteLine(sampleObject.number)
' This code example produces the following output:
' 10
' 11

L’exemple de code suivant montre comment ajouter un événement à une instance de la ExpandoObject classe.

class Program
{
    static void Main(string[] args)
    {
        dynamic sampleObject = new ExpandoObject();

        // Create a new event and initialize it with null.
        sampleObject.sampleEvent = null;

        // Add an event handler.
        sampleObject.sampleEvent += new EventHandler(SampleHandler);

        // Raise an event for testing purposes.
        sampleObject.sampleEvent(sampleObject, new EventArgs());
   }

    // Event handler.
    static void SampleHandler(object sender, EventArgs e)
    {
        Console.WriteLine("SampleHandler for {0} event", sender);
    }
}
// This code example produces the following output:
// SampleHandler for System.Dynamic.ExpandoObject event.

Module Module1

Sub Main()
    Dim sampleObject As Object = New ExpandoObject()

    ' Create a new event and initialize it with null.
    sampleObject.sampleEvent = Nothing

    ' Add an event handler.
    Dim handler As EventHandler = AddressOf SampleHandler
    sampleObject.sampleEvent =
        [Delegate].Combine(sampleObject.sampleEvent, handler)

    ' Raise an event for testing purposes.
    sampleObject.sampleEvent.Invoke(sampleObject, New EventArgs())

End Sub

' Event handler.
Sub SampleHandler(ByVal sender As Object, ByVal e As EventArgs)
    Console.WriteLine("SampleHandler for {0} event", sender)
End Sub

' This code example produces the following output:
' SampleHandler for System.Dynamic.ExpandoObject event.

End Module

Passer en tant que paramètre

Vous pouvez passer des instances de la ExpandoObject classe en tant que paramètres. Notez que ces instances sont traitées comme des objets dynamiques en C# et des objets à liaison tardive dans Visual Basic. Cela signifie que vous n’avez pas IntelliSense pour les membres d’objet et que vous ne recevez pas d’erreurs du compilateur lorsque vous appelez des membres inexistants. Si vous appelez un membre qui n’existe pas, une exception se produit.

L’exemple de code suivant montre comment créer et utiliser une méthode pour imprimer les noms et les valeurs des propriétés.

class Program
{
    static void Main(string[] args)
    {
        dynamic employee, manager;

        employee = new ExpandoObject();
        employee.Name = "John Smith";
        employee.Age = 33;

        manager = new ExpandoObject();
        manager.Name = "Allison Brown";
        manager.Age = 42;
        manager.TeamSize = 10;

        WritePerson(manager);
        WritePerson(employee);
    }
    private static void WritePerson(dynamic person)
    {
        Console.WriteLine("{0} is {1} years old.",
                          person.Name, person.Age);
        // The following statement causes an exception
        // if you pass the employee object.
        // Console.WriteLine("Manages {0} people", person.TeamSize);
    }
}
// This code example produces the following output:
// John Smith is 33 years old.
// Allison Brown is 42 years old.

Sub Main()
    Dim employee, manager As Object

    employee = New ExpandoObject()
    employee.Name = "John Smith"
    employee.Age = 33

    manager = New ExpandoObject()
    manager.Name = "Allison Brown"
    manager.Age = 42
    manager.TeamSize = 10

    WritePerson(manager)
    WritePerson(employee)
End Sub

Private Sub WritePerson(ByVal person As Object)

    Console.WriteLine("{0} is {1} years old.",
                      person.Name, person.Age)
    ' The following statement causes an exception
    ' if you pass the employee object.
    ' Console.WriteLine("Manages {0} people", person.TeamSize)

End Sub

Énumérer et supprimer des membres

La classe ExpandoObject implémente l’interface IDictionary<String, Object>. Cela permet l’énumération des membres ajoutés à l’instance de la classe au moment de l’exécution ExpandoObject . Cela peut être utile si vous ne savez pas au moment de la compilation quels membres une instance peut avoir.

L’exemple de code suivant montre comment convertir une instance de la classe vers l’interface ExpandoObjectIDictionary<TKey,TValue> et énumérer les membres de l’instance.

dynamic employee = new ExpandoObject();
employee.Name = "John Smith";
employee.Age = 33;

foreach (var property in (IDictionary<String, Object>)employee)
{
    Console.WriteLine(property.Key + ": " + property.Value);
}
// This code example produces the following output:
// Name: John Smith
// Age: 33

Dim employee As Object = New ExpandoObject()
employee.Name = "John Smith"
employee.Age = 33
For Each member In CType(employee, IDictionary(Of String, Object))
    Console.WriteLine(member.Key & ": " & member.Value)
Next
' This code example produces the following output:
' Name: John Smith
' Age: 33

Dans les langages qui n’ont pas de syntaxe pour supprimer des membres (tels que C# et Visual Basic), vous pouvez supprimer un membre en cas de conversion implicite d’une instance de ExpandoObject l’interface vers l’interface IDictionary<String, Object> , puis en supprimant le membre en tant que paire clé/valeur. Cela est illustré par l'exemple suivant.

dynamic employee = new ExpandoObject();
employee.Name = "John Smith";
((IDictionary<String, Object>)employee).Remove("Name");

Dim employee As Object = New ExpandoObject()
employee.Name = "John Smith"
CType(employee, IDictionary(Of String, Object)).Remove("Name")

Recevoir des notifications de modifications de propriété

La ExpandoObject classe implémente l’interface INotifyPropertyChanged et peut déclencher un PropertyChanged événement lorsqu’un membre est ajouté, supprimé ou modifié. Cela permet l’intégration ExpandoObject de classes à la liaison de données WINDOWS Presentation Foundation (WPF) et à d’autres environnements qui nécessitent une notification sur les modifications apportées au contenu de l’objet.

L’exemple de code suivant montre comment créer un gestionnaire d’événements pour l’événement PropertyChanged .

// Add "using System.ComponentModel;" line
// to the beginning of the file.
class Program
{
    static void Test()
    {
        dynamic employee = new ExpandoObject();
        ((INotifyPropertyChanged)employee).PropertyChanged +=
            new PropertyChangedEventHandler(HandlePropertyChanges);
        employee.Name = "John Smith";
    }

    private static void HandlePropertyChanges(
        object sender, PropertyChangedEventArgs e)
    {
        Console.WriteLine("{0} has changed.", e.PropertyName);
    }
}

' Add "Imports System.ComponentModel" line 
' to the beginning of the file.
Sub Main()
    Dim employee As Object = New ExpandoObject
    AddHandler CType(
        employee, INotifyPropertyChanged).PropertyChanged,
        AddressOf HandlePropertyChanges
    employee.Name = "John Smith"
End Sub

Private Sub HandlePropertyChanges(
       ByVal sender As Object, ByVal e As PropertyChangedEventArgs)
    Console.WriteLine("{0} has changed.", e.PropertyName)
End Sub