ExpandoObject Classe

Definizione

Rappresenta un oggetto i cui membri possono essere aggiunti e rimossi in modo dinamico in fase di esecuzione.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
Ereditarietà
ExpandoObject
Implementazioni

Commenti

La classe ExpandoObject consente di aggiungere ed eliminare membri delle relative istanze in fase di esecuzione, nonché di impostare e ottenere i valori di tali membri.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. Questa classe supporta l'associazione dinamica, che consente di usare una sintassi standard come sampleObject.sampleMember anziché una sintassi più complessa come sampleObject.GetAttribute("sampleMember").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 classe ExpandoObject implementa l'interfaccia DLR (Dynamic Language Runtime) standard IDynamicMetaObjectProvider, che consente di condividere le istanze della classe ExpandoObject tra i linguaggi che supportano il modello di interoperabilità 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. Ad esempio, è possibile creare un'istanza della classe ExpandoObject in C# e passarla quindi a una funzione IronPython.For example, you can create an instance of the ExpandoObject class in C# and then pass it to an IronPython function. Per ulteriori informazioni, vedere Panoramica di Dynamic Language Runtime e Introduzione a ExpandoObject nel C# sito Web di domande frequenti.For more information, see Dynamic Language Runtime Overview and Introducing the ExpandoObject on the C# Frequently Asked Questions Web site.

La classe ExpandoObject è un'implementazione del concetto di oggetto dinamico che consente di ottenere, impostare e richiamare membri.The ExpandoObject class is an implementation of the dynamic object concept that enables getting, setting, and invoking members. Se si desidera definire i tipi che dispongono di una semantica di invio dinamica, utilizzare la classe DynamicObject.If you want to define types that have their own dynamic dispatch semantics, use the DynamicObject class. Se si desidera definire il modo in cui gli oggetti dinamici partecipano al protocollo di interoperabilità e gestire la memorizzazione nella cache rapida della distribuzione dinamica di DLR, creare un'implementazione personalizzata dell'interfaccia IDynamicMetaObjectProvider.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.

Creazione di un'istanzaCreating an Instance

In C#, per abilitare l'associazione tardiva per un'istanza della classe ExpandoObject, è necessario utilizzare la parola chiave dynamic.In C#, to enable late binding for an instance of the ExpandoObject class, you must use the dynamic keyword. Per altre informazioni, vedere Uso del tipo dynamic.For more information, see Using Type dynamic.

In Visual Basic, le operazioni dinamiche sono supportate dall'associazione tardiva.In Visual Basic, dynamic operations are supported by late binding. Per ulteriori informazioni, vedere associazione anticipata e tardiva.For more information, see Early and Late Binding.

Nell'esempio di codice riportato di seguito viene illustrato come creare un'istanza della classe ExpandoObject.The following code example demonstrates how to create an instance of the ExpandoObject class.

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

Aggiunta di nuovi membriAdding New Members

È possibile aggiungere proprietà, metodi ed eventi alle istanze della classe ExpandoObject.You can add properties, methods, and events to instances of the ExpandoObject class.

Nell'esempio di codice riportato di seguito viene illustrato come aggiungere una nuova proprietà a un'istanza della classe ExpandoObject.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

I metodi rappresentano le espressioni lambda archiviate come delegati, che possono essere richiamate quando sono necessarie.The methods represent lambda expressions that are stored as delegates, which can be invoked when they are needed. Nell'esempio di codice seguente viene illustrato come aggiungere un metodo che incrementa un valore della proprietà dinamica.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

Nell'esempio di codice riportato di seguito viene illustrato come aggiungere un evento a un'istanza della classe ExpandoObject.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  

Passaggio come parametroPassing As a Parameter

È possibile passare le istanze della classe ExpandoObject come parametri.You can pass instances of the ExpandoObject class as parameters. Si noti che queste istanze vengono considerate come oggetti dinamici C# in e negli oggetti ad associazione tardiva in Visual Basic.Note that these instances are treated as dynamic objects in C# and late-bound objects in Visual Basic. Ciò significa che non si dispone di IntelliSense per i membri oggetto e non si ricevono errori del compilatore quando si chiamano membri inesistenti.This means that you do not have IntelliSense for object members and you do not receive compiler errors when you call non-existent members. Se si chiama un membro che non esiste, viene generata un'eccezione.If you call a member that does not exist, an exception occurs.

Nell'esempio di codice riportato di seguito viene illustrato come è possibile creare e utilizzare un metodo per stampare i nomi e i valori delle proprietà.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

Enumerazione ed eliminazione di membriEnumerating and Deleting Members

La classe ExpandoObject implementa l'interfaccia IDictionary<String, Object>.The ExpandoObject class implements the IDictionary<String, Object> interface. In questo modo viene abilitata l'enumerazione dei membri aggiunti all'istanza della classe ExpandoObject in fase di esecuzione.This enables enumeration of members added to the instance of the ExpandoObject class at run time. Questa operazione può essere utile se non si conosce in fase di compilazione i membri che un'istanza può avere.This can be useful if you do not know at compile time what members an instance might have.

Nell'esempio di codice riportato di seguito viene illustrato come è possibile eseguire il cast di un'istanza della classe ExpandoObject all'interfaccia IDictionary<TKey,TValue> ed enumerare i membri dell'istanza.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

Nei linguaggi che non dispongono di sintassi per l'eliminazione di membri ( C# ad esempio e Visual Basic), è possibile eliminare un membro eseguendo il cast implicito di un'istanza del ExpandoObject all'interfaccia IDictionary<String, Object> e quindi eliminando il membro come coppia chiave/valore.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. Questa operazione viene mostrata nell'esempio seguente.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")

Ricezione di notifiche di modifiche alle proprietàReceiving Notifications of Property Changes

La classe ExpandoObject implementa l'interfaccia INotifyPropertyChanged e può generare un evento PropertyChanged quando un membro viene aggiunto, eliminato o modificato.The ExpandoObject class implements the INotifyPropertyChanged interface and can raise a PropertyChanged event when a member is added, deleted, or modified. Ciò consente l'integrazione di ExpandoObject classe con Windows Presentation Foundation (WPF) data binding e altri ambienti che richiedono la notifica delle modifiche apportate al contenuto dell'oggetto.This enables ExpandoObject class integration with Windows Presentation Foundation (WPF) data binding and other environments that require notification about changes in the object content.

Nell'esempio di codice riportato di seguito viene illustrato come creare un gestore eventi per l'evento PropertyChanged.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

Costruttori

ExpandoObject()

Crea un nuovo oggetto ExpandoObject che non ha membri.Initializes a new ExpandoObject that does not have members.

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

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

Aggiunge il valore specificato all'interfaccia ICollection<T> con la chiave specificata.Adds the specified value to the ICollection<T> that has the specified key.

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

Rimuove tutti gli elementi dalla raccolta.Removes all items from the collection.

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

Stabilisce se l'interfaccia ICollection<T> contiene una coppia chiave/valore specifica.Determines whether the ICollection<T> contains a specific key and value.

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

Copia gli elementi dell'interfaccia ICollection<T> in una matrice di tipo KeyValuePair<TKey,TValue>, iniziando dall'indice di matrice specificato.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

Ottiene il numero di elementi in ICollection<T>.Gets the number of elements in the ICollection<T>.

ICollection<KeyValuePair<String,Object>>.IsReadOnly

Ottiene un valore che indica se ICollection<T> è di sola lettura.Gets a value indicating whether the ICollection<T> is read-only.

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

Rimuove una chiave e un valore dalla raccolta.Removes a key and value from the collection.

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

Aggiunge la chiave e il valore specificati al dizionario.Adds the specified key and value to the dictionary.

IDictionary<String,Object>.ContainsKey(String)

Determina se il dizionario contiene la chiave specificata.Determines whether the dictionary contains the specified key.

IDictionary<String,Object>.Item[String]

Ottiene o imposta l'elemento che dispone della chiave specificata.Gets or sets the element that has the specified key.

IDictionary<String,Object>.Keys

Ottiene un oggetto ICollection<T> che contiene le chiavi di IDictionary<TKey,TValue>.Gets an ICollection<T> that contains the keys of the IDictionary<TKey,TValue>.

IDictionary<String,Object>.Remove(String)

Rimuove l'elemento con la chiave specificata da IDictionary.Removes the element that has the specified key from the IDictionary.

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

Ottiene il valore associato alla chiave specificata.Gets the value associated with the specified key.

IDictionary<String,Object>.Values

Ottiene un oggetto ICollection<T> contenente i valori di IDictionary<TKey,TValue>.Gets an ICollection<T> that contains the values in the IDictionary<TKey,TValue>.

IDynamicMetaObjectProvider.GetMetaObject(Expression)

Il MetaObject fornito verrà inviato ai metodi virtuali dinamici.The provided MetaObject will dispatch to the dynamic virtual methods. L'oggetto può essere incapsulato all'interno di un altro MetaObject per fornire comportamento personalizzato per singole azioni.The object can be encapsulated inside another MetaObject to provide custom behavior for individual actions.

IEnumerable.GetEnumerator()

Restituisce un enumeratore che scorre la raccolta.Returns an enumerator that iterates through the collection.

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

Restituisce un enumeratore che scorre la raccolta.Returns an enumerator that iterates through the collection.

INotifyPropertyChanged.PropertyChanged

Si verifica quando un valore della proprietà viene modificato.Occurs when a property value changes.

Metodi di estensione

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

Tenta di rimuovere il valore con la chiave specificata da key da dictionary.Tries to remove the value with the specified key from the dictionary.

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

Tenta di aggiungere la chiave specificata da key e value a dictionary.Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

Restituisce un oggetto DataTable che contiene copie degli oggetti DataRow, dato un oggetto IEnumerable<T> di input dove il parametro generico T è 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)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è 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)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a collection of the child elements of every element and document in the source collection.

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

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a