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

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

Parameters

Retouren

true als de bewerking is geslaagd; anders, false. Als deze methode wordt geretourneerd false, bepaalt de runtimebinding van de taal het gedrag. (In de meeste gevallen wordt er een taalspecifieke runtime-uitzondering gegenereerd.

Voorbeelden

Stel dat u een gegevensstructuur nodig hebt om tekstuele en numerieke weergaven van getallen op te slaan. U wilt de waarde voor elke eigenschap afzonderlijk kunnen opgeven en ook alle eigenschappen in één instructie kunnen initialiseren.

In het volgende codevoorbeeld ziet u de DynamicNumber klasse, die is afgeleid van de DynamicObject klasse. DynamicNumber overschrijft de TryInvoke methode om initialisatie van alle eigenschappen tegelijk in te schakelen. Het overschrijft ook de TrySetMember en TryGetMember methoden om toegang tot afzonderlijke objecteigenschappen mogelijk te maken.

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

Opmerkingen

Klassen die zijn afgeleid van de DynamicObject klasse kunnen deze methode overschrijven om op te geven hoe bewerkingen die een object aanroepen, moeten worden uitgevoerd voor een dynamisch object. Wanneer de methode niet wordt overschreven, bepaalt de runtimebinding van de taal het gedrag. (In de meeste gevallen wordt er een runtime-uitzondering gegenereerd.)

Als deze methode wordt overschreven, wordt deze automatisch aangeroepen wanneer u een bewerking hebt zoals sampleObject(100), waar sampleObject deze is afgeleid van de DynamicObject klasse.

De bewerking voor het aanroepen van een object wordt ondersteund in C# maar niet in Visual Basic. De Visual Basic compiler verzendt nooit code om deze methode te gebruiken en de Visual Basic taal biedt geen ondersteuning voor syntaxis zoals sampleObject(100).