DynamicObject.TryInvoke(InvokeBinder, Object[], Object) Methode

Definition

Namespace:

System.Dynamic

Assembly:

System.Linq.Expressions.dll

Quelle:

DynamicObject.cs

Stellt die Implementierung für Vorgänge bereit, die ein Objekt aufrufen. Von der DynamicObject-Klasse abgeleitete Klassen können diese Methode überschreiben, um dynamisches Verhalten für Vorgänge wie das Aufrufen eines Objekts oder Delegaten anzugeben.

public:
 virtual bool TryInvoke(System::Dynamic::InvokeBinder ^ binder, cli::array <System::Object ^> ^ args, [Runtime::InteropServices::Out] System::Object ^ % result);

public virtual bool TryInvoke (System.Dynamic.InvokeBinder binder, object?[]? args, out object? result);

abstract member TryInvoke : System.Dynamic.InvokeBinder * obj[] * obj -> bool
override this.TryInvoke : System.Dynamic.InvokeBinder * obj[] * obj -> bool

Public Overridable Function TryInvoke (binder As InvokeBinder, args As Object(), ByRef result As Object) As Boolean

Parameter

binder

InvokeBinder

Stellt Informationen zum Aufrufvorgang bereit.

args

Object[]

Die Argumente, die während des Aufrufvorgangs an das Objekt übergeben werden. Beispielsweise ist für den sampleObject(100) Vorgang, bei dem sampleObject von der DynamicObject -Klasse abgeleitet wird, args[0] gleich 100.

result

Object

Das Ergebnis des Objektaufrufs.

Gibt zurück

Boolean

true, wenn der Vorgang erfolgreich ist, andernfalls false. Wenn die Methode false zurückgibt, wird das Verhalten vom Laufzeitbinder der Sprache bestimmt. (In den meisten Fällen wird eine sprachspezifische Laufzeitausnahme ausgelöst.)

Beispiele

Angenommen, Sie benötigen eine Datenstruktur, um textliche und numerische Darstellungen von Zahlen zu speichern. Sie möchten in der Lage sein, den Wert für jede Eigenschaft einzeln anzugeben und alle Eigenschaften in einer einzelnen Anweisung zu initialisieren.

Im folgenden Codebeispiel wird die DynamicNumber -Klasse veranschaulicht, die von der DynamicObject -Klasse abgeleitet ist. DynamicNumber überschreibt die TryInvoke -Methode, um die Initialisierung aller Eigenschaften gleichzeitig zu aktivieren. Außerdem werden die TrySetMember Methoden und TryGetMember außer Kraft gesetzt, um den Zugriff auf einzelne Objekteigenschaften zu ermöglichen.

// The class derived from DynamicObject.
public class DynamicNumber : DynamicObject
{
    // The inner dictionary to store field names and values.
    Dictionary<string, object> dictionary
        = new Dictionary<string, object>();

    // Get the property value.
    public override bool TryGetMember(
        GetMemberBinder binder, out object result)
    {
        return dictionary.TryGetValue(binder.Name, out result);
    }

    // Set the property value.
    public override bool TrySetMember(
        SetMemberBinder binder, object value)
    {
        dictionary[binder.Name] = value;
        return true;
    }

    // Initializing properties with arguments' values.
    public override bool TryInvoke(
        InvokeBinder binder, object[] args, out object result)
    {
        // The invoke operation in this case takes two arguments.
        // The first one is integer and the second one is string.
        if ((args.Length == 2) &&
            (args[0].GetType() == typeof(int)) &&
            (args[1].GetType() == typeof(String)))
        {
            // If the property already exists,
            // its value is changed.
            // Otherwise, a new property is created.
            if (dictionary.ContainsKey("Numeric"))
                dictionary["Numeric"] = args[0];
            else
                dictionary.Add("Numeric", args[0]);

            if (dictionary.ContainsKey("Textual"))
                dictionary["Textual"] = args[1];
            else
                dictionary.Add("Textual", args[1]);

            result = true;
            return true;
        }

        else
        {
            // If the number of arguments is wrong,
            // or if arguments are of the wrong type,
            // the method returns false.
            result = false;
            return false;
        }
    }
}
class Program
{
    static void Test(string[] args)
    {
        // Creating a dynamic object.
        dynamic number = new DynamicNumber();

        // Adding and initializing properties.
        // The TrySetMember method is called.
        number.Numeric = 1;
        number.Textual = "One";

        // Printing out the result.
        // The TryGetMember method is called.
        Console.WriteLine(number.Numeric + " " + number.Textual);

        // Invoking an object.
        // The TryInvoke method is called.
        number(2, "Two");
        Console.WriteLine(number.Numeric + " " + number.Textual);

        // The following statement produces a run-time exception
        // because in this example the method invocation
        // expects two arguments.
        // number(0);
    }
}

// This code example produces the following output:

// 1 One
// 2 Two

Hinweise

Von der DynamicObject -Klasse abgeleitete Klassen können diese Methode überschreiben, um anzugeben, wie Vorgänge zum Aufrufen eines Objekts für ein dynamisches Objekt ausgeführt werden sollen. Wenn die Methode nicht überschrieben wird, bestimmt der Laufzeitbinder der Sprache das Verhalten. (In den meisten Fällen wird eine Laufzeitausnahme ausgelöst.)

Wenn diese Methode überschrieben wird, wird sie automatisch aufgerufen, wenn Sie einen Vorgang wie sampleObject(100)haben, wobei sampleObject von der DynamicObject -Klasse abgeleitet wird.

Der Vorgang zum Aufrufen eines Objekts wird in C# unterstützt, aber nicht in Visual Basic. Der Visual Basic-Compiler gibt nie Code aus, um diese Methode zu verwenden, und die Visual Basic-Sprache unterstützt keine Syntax wie sampleObject(100).