Třída System.Dynamic.ExpandoObject

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Třída ExpandoObject umožňuje přidat a odstranit členy jejích instancí za běhu a také nastavit a získat hodnoty těchto členů. Tato třída podporuje dynamickou vazbu, která umožňuje používat standardní syntaxi jako sampleObject.sampleMember místo složitější syntaxe, jako je sampleObject.GetAttribute("sampleMember").

Třída ExpandoObject implementuje standardní rozhraní IDynamicMetaObjectProviderDLR (Dynamic Language Runtime), které umožňuje sdílet instance ExpandoObject třídy mezi jazyky, které podporují model interoperability DLR. Můžete například vytvořit instanci ExpandoObject třídy v jazyce C# a předat ji funkci IronPython. Další informace naleznete v tématu Dynamic Language Runtime Overview and Introducing the ExpandoObject.

Třída ExpandoObject je implementace konceptu dynamického objektu, která umožňuje získání, nastavení a vyvolání členů. Pokud chcete definovat typy, které mají vlastní dynamickou sémantiku odesílání, použijte DynamicObject třídu. Pokud chcete definovat, jak se dynamické objekty účastní protokolu interoperability a spravují ukládání do mezipaměti pro rychlé dynamické odesílání DLR, vytvořte svou vlastní implementaci rozhraní IDynamicMetaObjectProvider.

Vytvoření instance

Chcete-li v jazyce C# povolit pozdní vazbu pro instanci ExpandoObject třídy, musíte použít dynamic klíčové slovo. Další informace naleznete v tématu Použití dynamického typu.

V jazyce Visual Basic jsou dynamické operace podporovány pozdní vazbou. Další informace naleznete v tématu Časná a pozdní vazba (Visual Basic).

Následující příklad kódu ukazuje, jak vytvořit instanci ExpandoObject třídy.

dynamic sampleObject = new ExpandoObject();

Dim sampleObject As Object = New ExpandoObject()

Přidání nových členů

Do instancí ExpandoObject třídy můžete přidat vlastnosti, metody a události.

Následující příklad kódu ukazuje, jak přidat novou vlastnost do instance ExpandoObject třídy.

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

Metody představují výrazy lambda, které jsou uloženy jako delegáty, které lze vyvolat v případě potřeby. Následující příklad kódu ukazuje, jak přidat metodu, která zvýší hodnotu dynamické vlastnosti.

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

Následující příklad kódu ukazuje, jak přidat událost do instance ExpandoObject třídy.

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

Předat jako parametr

Instance ExpandoObject třídy můžete předat jako parametry. Všimněte si, že tyto instance jsou považovány za dynamické objekty v jazyce C# a objekty s pozdní vazbou v jazyce Visual Basic. To znamená, že nemáte technologii IntelliSense pro členy objektů a při volání neexistujících členů neobdržíte chyby kompilátoru. Pokud zavoláte člena, který neexistuje, dojde k výjimce.

Následující příklad kódu ukazuje, jak můžete vytvořit a použít metodu k tisku názvů a hodnot vlastností.

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($"{person.Name} is {person.Age} years old.");
        // The following statement causes an exception
        // if you pass the employee object.
        // Console.WriteLine($"Manages {person.TeamSize} people");
    }
}
// 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

Vytvoření výčtu a odstranění členů

Třída ExpandoObject implementuje rozhraní IDictionary<String, Object>. To umožňuje výčet členů přidaných do instance ExpandoObject třídy za běhu. To může být užitečné, pokud nevíte v době kompilace, které členy může instance mít.

Následující příklad kódu ukazuje, jak můžete přetypovat instanci ExpandoObject třídy do IDictionary<TKey,TValue> rozhraní a vytvořit výčet členů 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

V jazycích, které nemají syntaxi pro odstranění členů (například C# a Visual Basic), můžete člena odstranit implicitním přetypováním instance ExpandoObject na IDictionary<String, Object> rozhraní a následným odstraněním člena jako pár klíče/hodnoty. To je znázorněno v následujícím příkladu.

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

Příjem oznámení o změnách vlastností

Třída ExpandoObject implementuje INotifyPropertyChanged rozhraní a může vyvolat PropertyChanged událost při přidání, odstranění nebo úpravě člena. To umožňuje ExpandoObject integraci tříd s datovou vazbou WPF (Windows Presentation Foundation) a dalšími prostředími, která vyžadují oznámení o změnách v obsahu objektu.

Následující příklad kódu ukazuje, jak vytvořit obslužnou rutinu pro událost 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($"{e.PropertyName} has changed.");
    }
}

' 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