ExpandoObject Classe

Définition

Représente un objet dont les membres peuvent être ajoutés et supprimés de manière dynamique au moment de l'exécution.Represents an object whose members can be dynamically added and removed at run time.

public ref class ExpandoObject sealed : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<System::String ^, System::Object ^>>, System::Collections::Generic::IDictionary<System::String ^, System::Object ^>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<System::String ^, System::Object ^>>, System::ComponentModel::INotifyPropertyChanged, System::Dynamic::IDynamicMetaObjectProvider
public sealed class ExpandoObject : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<string,object>>, System.Collections.Generic.IDictionary<string,object>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,object>>, System.ComponentModel.INotifyPropertyChanged, System.Dynamic.IDynamicMetaObjectProvider
type ExpandoObject = class
    interface IDynamicMetaObjectProvider
    interface IDictionary<string, obj>
    interface INotifyPropertyChanged
    interface ICollection<KeyValuePair<string, obj>>
    interface seq<KeyValuePair<string, obj>>
    interface IEnumerable
Public NotInheritable Class ExpandoObject
Implements ICollection(Of KeyValuePair(Of String, Object)), IDictionary(Of String, Object), IDynamicMetaObjectProvider, IEnumerable(Of KeyValuePair(Of String, Object)), INotifyPropertyChanged
Héritage
ExpandoObject
Implémente

Remarques

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’extraire des valeurs de ces membres.The ExpandoObject class enables you to add and delete members of its instances at run time and also to set and get values of these members. Cette classe prend en charge la liaison dynamique, qui vous permet d’utiliser sampleObject.sampleMember une syntaxe standard comme au lieu sampleObject.GetAttribute("sampleMember")d’une syntaxe plus complexe comme.This class supports dynamic binding, which enables you to use standard syntax like sampleObject.sampleMember instead of more complex syntax like sampleObject.GetAttribute("sampleMember").

La ExpandoObject classe implémente l’interface IDynamicMetaObjectProviderdu Dynamic Language Runtime (DLR) standard, qui vous permet de partager des instances ExpandoObject de la classe entre les langages qui prennent en charge le modèle d’interopérabilité du DLR.The ExpandoObject class implements the standard Dynamic Language Runtime (DLR) interface IDynamicMetaObjectProvider, which enables you to share instances of the ExpandoObject class between languages that support the DLR interoperability model. Par exemple, vous pouvez créer une instance de la ExpandoObject classe dans C# et la passer à une fonction IronPython.For example, you can create an instance of the ExpandoObject class in C# and then pass it to an IronPython function. Pour plus d’informations, consultez vue d’ensemble du Dynamic Language Runtime et présentation C# de l’ExpandoObject sur le site Web Forum aux questions.For more information, see Dynamic Language Runtime Overview and Introducing the ExpandoObject on the C# Frequently Asked Questions Web site.

La ExpandoObject classe est une implémentation du concept d’objet dynamique qui permet d’obtenir, de définir et d’appeler des membres.The ExpandoObject class is an implementation of the dynamic object concept that enables getting, setting, and invoking members. Si vous souhaitez définir des types qui ont leur propre sémantique de distribution dynamique, utilisez la DynamicObject classe.If you want to define types that have their own dynamic dispatch semantics, use the DynamicObject class. Si vous souhaitez définir la manière dont les objets dynamiques participent au protocole d’interopérabilité et gèrent la mise en cache de distribution dynamique rapide du DLR IDynamicMetaObjectProvider , créez votre propre implémentation de l’interface.If you want to define how dynamic objects participate in the interoperability protocol and manage DLR fast dynamic dispatch caching, create your own implementation of the IDynamicMetaObjectProvider interface.

Création d’une instanceCreating an Instance

Dans C#, pour activer la liaison tardive pour une instance de ExpandoObject la classe, vous devez utiliser dynamic le mot clé.In C#, to enable late binding for an instance of the ExpandoObject class, you must use the dynamic keyword. Pour plus d’informations, consultez Utilisation du type dynamic.For more information, see Using Type dynamic.

Dans Visual Basic, les opérations dynamiques sont prises en charge par la liaison tardive.In Visual Basic, dynamic operations are supported by late binding. Pour plus d’informations, consultez liaison précoce et tardive.For more information, see Early and Late Binding.

L’exemple de code suivant montre comment créer une instance de la ExpandoObject classe.The following code example demonstrates how to create an instance of the ExpandoObject class.

dynamic sampleObject = new ExpandoObject();
Dim sampleObject As Object = New ExpandoObject()

Ajout de nouveaux membresAdding New Members

Vous pouvez ajouter des propriétés, des méthodes et des événements aux instances ExpandoObject de la classe.You can add properties, methods, and events to instances of the ExpandoObject class.

L’exemple de code suivant montre comment ajouter une nouvelle propriété à une instance de la ExpandoObject classe.The following code example demonstrates how to add a new property to an instance of the ExpandoObject class.

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 qui sont stockées en tant que délégués, qui peuvent être appelées lorsqu’elles sont nécessaires.The methods represent lambda expressions that are stored as delegates, which can be invoked when they are needed. L’exemple de code suivant montre comment ajouter une méthode qui incrémente une valeur de la propriété dynamique.The following code example demonstrates how to add a method that increments a value of the dynamic property.

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.The following code example demonstrates how to add an event to an instance of the ExpandoObject class.

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  

Passage en tant que paramètrePassing As a Parameter

Vous pouvez passer des instances de ExpandoObject la classe en tant que paramètres.You can pass instances of the ExpandoObject class as parameters. Notez que ces instances sont traitées comme des objets dynamiques C# dans et des objets à liaison tardive dans Visual Basic.Note that these instances are treated as dynamic objects in C# and late-bound objects in Visual Basic. Cela signifie que vous n’avez pas IntelliSense pour les membres d’objet et que vous ne recevez pas d’erreurs de compilation lorsque vous appelez des membres inexistants.This means that you do not have IntelliSense for object members and you do not receive compiler errors when you call non-existent members. Si vous appelez un membre qui n’existe pas, une exception se produit.If you call a member that does not exist, an exception occurs.

L’exemple de code suivant montre comment vous pouvez créer et utiliser une méthode pour imprimer les noms et les valeurs des propriétés.The following code example demonstrates how you can create and use a method to print the names and values of properties.

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ération et suppression de membresEnumerating and Deleting Members

La classe ExpandoObject implémente l'interface IDictionary<String, Object>.The ExpandoObject class implements the IDictionary<String, Object> interface. Cela permet l’énumération des membres ajoutés à l’instance ExpandoObject de la classe au moment de l’exécution.This enables enumeration of members added to the instance of the ExpandoObject class at run time. Cela peut être utile si vous ne savez pas au moment de la compilation quels membres une instance peut avoir.This can be useful if you do not know at compile time what members an instance might have.

L’exemple de code suivant montre comment vous pouvez effectuer un cast d' ExpandoObject une instance de IDictionary<TKey,TValue> la classe en interface et énumérer les membres de l’instance.The following code example shows how you can cast an instance of the ExpandoObject class to the IDictionary<TKey,TValue> interface and enumerate the instance's members.

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 C# membres (tels que et Visual Basic), vous pouvez supprimer un membre en effectuant un ExpandoObject cast implicite d’une instance de vers l' IDictionary<String, Object> interface, puis en supprimant le membre en tant que paire clé/valeur.In languages that do not have syntax for deleting members (such as C# and Visual Basic), you can delete a member by implicitly casting an instance of the ExpandoObject to the IDictionary<String, Object> interface and then deleting the member as a key/value pair. L'exemple suivant le démontre.This is shown in the following example.

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")

Réception des notifications de modifications de propriétéReceiving Notifications of Property Changes

La ExpandoObject classe implémente l' INotifyPropertyChanged interface et peut déclencher un PropertyChanged événement lors de l’ajout, de la suppression ou de la modification d’un membre.The ExpandoObject class implements the INotifyPropertyChanged interface and can raise a PropertyChanged event when a member is added, deleted, or modified. Cela permet ExpandoObject l’intégration de classes avec la liaison de données Windows Presentation Foundation (WPF) et d’autres environnements qui requièrent une notification concernant les modifications apportées au contenu de l’objet.This enables ExpandoObject class integration with Windows Presentation Foundation (WPF) data binding and other environments that require notification about changes in the object content.

L’exemple de code suivant montre comment créer un gestionnaire d’événements pour PropertyChanged l’événement.The following code example demonstrates how to create an event handler for the PropertyChanged event.

// 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

Constructeurs

ExpandoObject()

Initialise un nouveau ExpandoObject qui n'a pas de membres.Initializes a new ExpandoObject that does not have members.

Méthodes

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)

Implémentations d’interfaces explicites

ICollection<KeyValuePair<String,Object>>.Add(KeyValuePair<String,Object>)

Ajoute la valeur spécifiée au ICollection<T> ayant la clé spécifiée.Adds the specified value to the ICollection<T> that has the specified key.

ICollection<KeyValuePair<String,Object>>.Clear()

Supprime tous les éléments de la collection.Removes all items from the collection.

ICollection<KeyValuePair<String,Object>>.Contains(KeyValuePair<String,Object>)

Détermine si ICollection<T> contient une clé et une valeur spécifiques.Determines whether the ICollection<T> contains a specific key and value.

ICollection<KeyValuePair<String,Object>>.CopyTo(KeyValuePair<String,Object>[], Int32)

Copie les éléments de ICollection<T> dans un tableau de type KeyValuePair<TKey,TValue>, en commençant au niveau de l'index de tableau spécifié.Copies the elements of the ICollection<T> to an array of type KeyValuePair<TKey,TValue>, starting at the specified array index.

ICollection<KeyValuePair<String,Object>>.Count

Obtient le nombre d’éléments dans ICollection<T>.Gets the number of elements in the ICollection<T>.

ICollection<KeyValuePair<String,Object>>.IsReadOnly

Obtient une valeur indiquant si ICollection<T> est en lecture seule.Gets a value indicating whether the ICollection<T> is read-only.

ICollection<KeyValuePair<String,Object>>.Remove(KeyValuePair<String,Object>)

Supprime une clé et une valeur de la collection.Removes a key and value from the collection.

IDictionary<String,Object>.Add(String, Object)

Ajoute la clé et la valeur spécifiées au dictionnaire.Adds the specified key and value to the dictionary.

IDictionary<String,Object>.ContainsKey(String)

Détermine si le dictionnaire contient la clé spécifiée.Determines whether the dictionary contains the specified key.

IDictionary<String,Object>.Item[String]

Obtient ou définit l'élément qui contient la clé spécifiée.Gets or sets the element that has the specified key.

IDictionary<String,Object>.Keys

Obtient un ICollection<T> qui contient les clés de IDictionary<TKey,TValue>.Gets an ICollection<T> that contains the keys of the IDictionary<TKey,TValue>.

IDictionary<String,Object>.Remove(String)

Supprime de IDictionary l'élément ayant la clé spécifiée.Removes the element that has the specified key from the IDictionary.

IDictionary<String,Object>.TryGetValue(String, Object)

Obtient la valeur associée à la clé spécifiée.Gets the value associated with the specified key.

IDictionary<String,Object>.Values

Obtient un objet ICollection<T> qui contient les valeurs de l'objet IDictionary<TKey,TValue>.Gets an ICollection<T> that contains the values in the IDictionary<TKey,TValue>.

IDynamicMetaObjectProvider.GetMetaObject(Expression)

Le MetaObject fourni est distribué aux méthodes virtuelles dynamiques.The provided MetaObject will dispatch to the dynamic virtual methods. L'objet peut être encapsulé dans un autre MetaObject pour définir un comportement personnalisé pour des actions individuelles.The object can be encapsulated inside another MetaObject to provide custom behavior for individual actions.

IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein de la collection.Returns an enumerator that iterates through the collection.

IEnumerable<KeyValuePair<String,Object>>.GetEnumerator()

Retourne un énumérateur qui itère au sein de la collection.Returns an enumerator that iterates through the collection.

INotifyPropertyChanged.PropertyChanged

Se produit en cas de modification d'une valeur de propriété.Occurs when a property value changes.

Méthodes d’extension

Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tries to remove the value with the specified key from the dictionary.

TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à