DynamicObject.TryInvoke(InvokeBinder, Object[], Object) Método

Definición

Espacio de nombres:

System.Dynamic

Ensamblado:

System.Linq.Expressions.dll

Source:

DynamicObject.cs

Proporciona la implementación para las operaciones que invocan un objeto. Las clases derivadas de la clase DynamicObject pueden invalidar este método para especificar un comportamiento dinámico para operaciones como invocar un objeto o un delegado.

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

Parámetros

binder

InvokeBinder

Proporciona información sobre la operación de invocación.

args

Object[]

Argumentos que se pasan al objeto durante la operación de invocación. Por ejemplo, para la sampleObject(100) operación, donde sampleObject se deriva de la DynamicObject clase , args[0] es igual a 100.

result

Object

Resultado de la invocación de objeto.

Devoluciones

Boolean

true si la operación es correcta; de lo contrario, false. Si este método devuelve false, el enlazador del lenguaje en tiempo de ejecución determina el comportamiento. (En la mayoría de los casos, se inicia una excepción específica del lenguaje en tiempo de ejecución).

Ejemplos

Supongamos que necesita una estructura de datos para almacenar representaciones textuales y numéricas de números. Quiere poder especificar el valor de cada propiedad individualmente y también poder inicializar todas las propiedades en una sola instrucción.

En el ejemplo de código siguiente se muestra la DynamicNumber clase , que se deriva de la DynamicObject clase . DynamicNumber invalida el método para habilitar la TryInvoke inicialización de todas las propiedades a la vez. También invalida los métodos y TryGetMember para habilitar el TrySetMember acceso a propiedades de objeto individuales.

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

Comentarios

Las clases derivadas de la DynamicObject clase pueden invalidar este método para especificar cómo se deben realizar las operaciones que invocan un objeto para un objeto dinámico. Cuando el método no se invalida, el enlazador en tiempo de ejecución del lenguaje determina el comportamiento. (En la mayoría de los casos, se inicia una excepción en tiempo de ejecución).

Si este método se invalida, se invoca automáticamente cuando se tiene una operación como sampleObject(100), donde sampleObject se deriva de la DynamicObject clase .

La operación para invocar un objeto se admite en C# pero no en Visual Basic. El compilador de Visual Basic nunca emite código para usar este método y el lenguaje de Visual Basic no admite sintaxis como sampleObject(100).