Expression.Call Método

Referencia

Definición

Espacio de nombres:: System.Linq.Expressions

Ensamblado:: System.Linq.Expressions.dll

Ensamblado:: System.Core.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Crea una interfaz MethodCallExpression.

Sobrecargas

Call(MethodInfo, Expression, Expression, Expression, Expression, Expression)	Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma cinco argumentos.
Call(Expression, MethodInfo, Expression, Expression, Expression)	Crea un objeto MethodCallExpression que representa una llamada a un método que toma tres argumentos.
Call(Type, String, Type[], Expression[])	Crea un objeto MethodCallExpression que representa una llamada a un método `static` (`Shared` en Visual Basic) llamando al método del generador apropiado.
Call(MethodInfo, Expression, Expression, Expression)	Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma tres argumentos.
Call(Expression, String, Type[], Expression[])	Crea un objeto MethodCallExpression que representa una llamada a un método llamando al método del generador apropiado.
Call(Expression, MethodInfo, Expression, Expression)	Crea un objeto MethodCallExpression que representa una llamada a un método que toma dos argumentos.
Call(MethodInfo, Expression, Expression, Expression, Expression)	Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma cuatro argumentos.
Call(Expression, MethodInfo, Expression[])	Crea un objeto MethodCallExpression que representa una llamada a un método que toma argumentos.
Call(Expression, MethodInfo, IEnumerable<Expression>)	Crea un objeto MethodCallExpression que representa una llamada a un método que toma argumentos.
Call(MethodInfo, Expression[])	Crea un objeto MethodCallExpression que representa una llamada a un método `static` (`Shared` en Visual Basic) con argumentos.
Call(MethodInfo, Expression)	Crea un objeto MethodCallExpression que representa una llamada a un método `static` (`Shared` en Visual Basic) que toma un argumento.
Call(MethodInfo, IEnumerable<Expression>)	Crea un objeto MethodCallExpression que representa una llamada a un método estático (Shared en Visual Basic).
Call(Expression, MethodInfo)	Crea un objeto MethodCallExpression que representa una llamada a un método que no toma ningún argumento.
Call(MethodInfo, Expression, Expression)	Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma dos argumentos.

Call(MethodInfo, Expression, Expression, Expression, Expression, Expression)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma cinco argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Reflection::MethodInfo ^ method, System::Linq::Expressions::Expression ^ arg0, System::Linq::Expressions::Expression ^ arg1, System::Linq::Expressions::Expression ^ arg2, System::Linq::Expressions::Expression ^ arg3, System::Linq::Expressions::Expression ^ arg4);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3, System.Linq.Expressions.Expression arg4);

static member Call : System.Reflection.MethodInfo * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (method As MethodInfo, arg0 As Expression, arg1 As Expression, arg2 As Expression, arg3 As Expression, arg4 As Expression) As MethodCallExpression

Parámetros

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

arg0: Expression

Expression que representa el primer argumento.

arg1: Expression

Objeto Expression que representa el segundo argumento.

arg2: Expression

Expression que representa el tercer argumento.

arg3: Expression

Expression que representa el cuarto argumento.

arg4: Expression

Expression que representa el quinto argumento.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

Se aplica a

Call(Expression, MethodInfo, Expression, Expression, Expression)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método que toma tres argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Linq::Expressions::Expression ^ instance, System::Reflection::MethodInfo ^ method, System::Linq::Expressions::Expression ^ arg0, System::Linq::Expressions::Expression ^ arg1, System::Linq::Expressions::Expression ^ arg2);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression instance, System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2);

static member Call : System.Linq.Expressions.Expression * System.Reflection.MethodInfo * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (instance As Expression, method As MethodInfo, arg0 As Expression, arg1 As Expression, arg2 As Expression) As MethodCallExpression

Parámetros

instance: Expression

Expression que especifica la instancia de una llamada de instancia. (Pasa null para un método estático, que en Visual Basic es compartido).

method: MethodInfo

Objeto MethodInfo que representa el método de destino.

arg0: Expression

Expression que representa el primer argumento.

arg1: Expression

Objeto Expression que representa el segundo argumento.

arg2: Expression

Expression que representa el tercer argumento.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Se aplica a

Call(Type, String, Type[], Expression[])

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método static (Shared en Visual Basic) llamando al método del generador apropiado.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(Type ^ type, System::String ^ methodName, cli::array <Type ^> ^ typeArguments, ... cli::array <System::Linq::Expressions::Expression ^> ^ arguments);

public static System.Linq.Expressions.MethodCallExpression Call (Type type, string methodName, Type[] typeArguments, params System.Linq.Expressions.Expression[] arguments);

public static System.Linq.Expressions.MethodCallExpression Call (Type type, string methodName, Type[]? typeArguments, params System.Linq.Expressions.Expression[]? arguments);

static member Call : Type * string * Type[] * System.Linq.Expressions.Expression[] -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (type As Type, methodName As String, typeArguments As Type(), ParamArray arguments As Expression()) As MethodCallExpression

Parámetros

type: Type

Tipo que contiene el método static (Shared en Visual Basic) especificado.

methodName: String

Nombre del método.

typeArguments: Type[]

Matriz de objetos Type que especifican los parámetros de tipo del método genérico. Este argumento debería ser null cuando methodName especifica un método no genérico.

arguments: Expression[]

Matriz de objetos Expression que representan los argumentos del método.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call, cuya propiedad Method se establece en el objeto MethodInfo que representa el método static (Shared en Visual Basic) especificado, y cuya propiedad Arguments se establece en los argumentos especificados.

Excepciones

ArgumentNullException

type o methodName es null.

InvalidOperationException

No se encuentra en type o sus tipos base ningún método cuyo nombre sea methodName, cuyos parámetros de tipo coincidan con typeArguments y cuyos tipos de parámetro se correspondan con arguments.

o bien

Se han encontrado en type o sus tipos base varios métodos cuyo nombre es methodName, cuyos parámetros de tipo coinciden con typeArguments y cuyos tipos de parámetro se corresponden con arguments.

Comentarios

La Type propiedad del resultante MethodCallExpression es igual al tipo de valor devuelto del método indicado por methodName. La propiedad Object es null.

Se aplica a

Call(MethodInfo, Expression, Expression, Expression)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma tres argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Reflection::MethodInfo ^ method, System::Linq::Expressions::Expression ^ arg0, System::Linq::Expressions::Expression ^ arg1, System::Linq::Expressions::Expression ^ arg2);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2);

static member Call : System.Reflection.MethodInfo * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (method As MethodInfo, arg0 As Expression, arg1 As Expression, arg2 As Expression) As MethodCallExpression

Parámetros

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

arg0: Expression

Expression que representa el primer argumento.

arg1: Expression

Objeto Expression que representa el segundo argumento.

arg2: Expression

Expression que representa el tercer argumento.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

Se aplica a

Call(Expression, String, Type[], Expression[])

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método llamando al método del generador apropiado.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Linq::Expressions::Expression ^ instance, System::String ^ methodName, cli::array <Type ^> ^ typeArguments, ... cli::array <System::Linq::Expressions::Expression ^> ^ arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression instance, string methodName, Type[] typeArguments, params System.Linq.Expressions.Expression[] arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression instance, string methodName, Type[]? typeArguments, params System.Linq.Expressions.Expression[]? arguments);

static member Call : System.Linq.Expressions.Expression * string * Type[] * System.Linq.Expressions.Expression[] -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (instance As Expression, methodName As String, typeArguments As Type(), ParamArray arguments As Expression()) As MethodCallExpression

Parámetros

instance: Expression

Expression en cuyo valor de propiedad Type se buscará un método específico.

methodName: String

Nombre del método.

typeArguments: Type[]

Matriz de objetos Type que especifican los parámetros de tipo del método genérico. Este argumento debería ser null cuando methodName especifica un método no genérico.

arguments: Expression[]

Matriz de objetos Expression que representa los argumentos del método.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call, cuya propiedad Object es instance, Method se establece en el objeto MethodInfo que representa el método de instancia especificado y Arguments se establece en los argumentos especificados.

Excepciones

ArgumentNullException

instance o methodName es null.

InvalidOperationException

No se encuentra en instance.Type o sus tipos base ningún método cuyo nombre sea methodName, cuyos parámetros de tipo coincidan con typeArguments y cuyos tipos de parámetro se correspondan con arguments.

o bien

Se han encontrado en instance.Type o sus tipos base varios métodos cuyo nombre es methodName, cuyos parámetros de tipo coinciden con typeArguments y cuyos tipos de parámetro se corresponden con arguments.

Comentarios

La Type propiedad del resultante MethodCallExpression es igual al tipo de valor devuelto del método indicado por methodName.

Se aplica a

Call(Expression, MethodInfo, Expression, Expression)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método que toma dos argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Linq::Expressions::Expression ^ instance, System::Reflection::MethodInfo ^ method, System::Linq::Expressions::Expression ^ arg0, System::Linq::Expressions::Expression ^ arg1);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression instance, System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1);

static member Call : System.Linq.Expressions.Expression * System.Reflection.MethodInfo * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (instance As Expression, method As MethodInfo, arg0 As Expression, arg1 As Expression) As MethodCallExpression

Parámetros

instance: Expression

Expression que especifica la instancia de una llamada de instancia. (Pasa null para un método estático, que en Visual Basic es compartido).

method: MethodInfo

Objeto MethodInfo que representa el método de destino.

arg0: Expression

Expression que representa el primer argumento.

arg1: Expression

Objeto Expression que representa el segundo argumento.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear una expresión que llama a un método de instancia que tiene dos argumentos.

// Add the following directive to your file:
// using System.Linq.Expressions;
public class SampleClass
{
    public int AddIntegers(int arg1, int arg2)
    {
        return arg1 + arg2;
    }
}

static public void TestCall()
{
    // This expression represents a call to an instance method that has two arguments.
    // The first argument is an expression that creates a new object of the specified type.
    Expression callExpr = Expression.Call(
        Expression.New(typeof(SampleClass)),
        typeof(SampleClass).GetMethod("AddIntegers", new Type[] { typeof(int), typeof(int) }),
        Expression.Constant(1),
        Expression.Constant(2)
        );

    // Print out the expression.
    Console.WriteLine(callExpr.ToString());

    // The following statement first creates an expression tree,
    // then compiles it, and then executes it.
    Console.WriteLine(Expression.Lambda<Func<int>>(callExpr).Compile()());

    // This code example produces the following output:
    //
    // new SampleClass().AddIntegers(1, 2)
    // 3
}

' Add the following directive to your file:
' Imports System.Linq.Expressions  

Public Class SampleClass
    Public Function AddIntegers(ByVal arg1 As Integer, ByVal arg2 As Integer) As Integer
        Return (arg1 + arg2)
    End Function
End Class
Public Shared Sub TestCall()
    ' This expression represents a call to an instance method that has two arguments.
    ' The first argument is an expression that creates a new object of the specified type.
    Dim callExpr As Expression = Expression.Call(
        Expression.[New](GetType(SampleClass)),
        GetType(SampleClass).GetMethod("AddIntegers", New Type() {GetType(Integer), GetType(Integer)}),
        Expression.Constant(1),
        Expression.Constant(2)
      )

    ' Print the expression.
    Console.WriteLine(callExpr.ToString())

    ' The following statement first creates an expression tree,
    ' then compiles it, and then executes it.
    Console.WriteLine(Expression.Lambda(Of Func(Of Integer))(callExpr).Compile()())
End Sub

' This code example produces the following output:
'
' new SampleClass().AddIntegers(1, 2)
' 3

Se aplica a

Call(MethodInfo, Expression, Expression, Expression, Expression)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma cuatro argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Reflection::MethodInfo ^ method, System::Linq::Expressions::Expression ^ arg0, System::Linq::Expressions::Expression ^ arg1, System::Linq::Expressions::Expression ^ arg2, System::Linq::Expressions::Expression ^ arg3);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3);

static member Call : System.Reflection.MethodInfo * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (method As MethodInfo, arg0 As Expression, arg1 As Expression, arg2 As Expression, arg3 As Expression) As MethodCallExpression

Parámetros

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

arg0: Expression

Expression que representa el primer argumento.

arg1: Expression

Objeto Expression que representa el segundo argumento.

arg2: Expression

Expression que representa el tercer argumento.

arg3: Expression

Expression que representa el cuarto argumento.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

Se aplica a

Call(Expression, MethodInfo, Expression[])

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método que toma argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Linq::Expressions::Expression ^ instance, System::Reflection::MethodInfo ^ method, ... cli::array <System::Linq::Expressions::Expression ^> ^ arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression instance, System.Reflection.MethodInfo method, params System.Linq.Expressions.Expression[] arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method, params System.Linq.Expressions.Expression[]? arguments);

static member Call : System.Linq.Expressions.Expression * System.Reflection.MethodInfo * System.Linq.Expressions.Expression[] -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (instance As Expression, method As MethodInfo, ParamArray arguments As Expression()) As MethodCallExpression

Parámetros

instance: Expression

Expression que especifica la instancia para una llamada al método de instancia (pasa null para un método static, Shared en Visual Basic).

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

arguments: Expression[]

Matriz de objetos Expression que se va a usar para rellenar la colección de Arguments.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y Object, Method y Arguments se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

o bien

instance es null y method representa un método de instancia.

o bien

arguments no es null y uno o varios de sus elementos son null.

ArgumentException

instance.Type no se puede asignar al tipo declarativo del método representado por method.

o bien

El número de elementos de arguments no es igual al número de parámetros del método representado por method.

o bien

Uno o varios elementos de arguments no se pueden asignar al parámetro correspondiente del método representado por method.

Comentarios

Para representar una llamada a un static método (Shared en Visual Basic), pase null para el instance parámetro cuando llame a este método o llame Call a en su lugar.

Si method representa un método de instancia, la Type propiedad de instance debe ser asignable al tipo declarativo del método representado por method.

Si arguments no nulles , debe tener el mismo número de elementos que el número de parámetros para el método representado por method. Cada elemento de arguments no debe ser null y debe ser asignable al parámetro correspondiente de , posiblemente después de methodlas comillas.

Nota

Un elemento se citará solo si el parámetro de método correspondiente es de tipo Expression. Entre comillas significa que el elemento se encapsula en un Quote nodo. El nodo resultante es un UnaryExpression cuya Operand propiedad es el elemento de arguments.

La Arguments propiedad del resultante MethodCallExpression está vacía si arguments es null. De lo contrario, contiene los mismos elementos que arguments, algunos de los cuales pueden ser entrecomillados.

La Type propiedad del resultado MethodCallExpression es igual al tipo de valor devuelto del método representado por method.

Se aplica a

Call(Expression, MethodInfo, IEnumerable<Expression>)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método que toma argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Linq::Expressions::Expression ^ instance, System::Reflection::MethodInfo ^ method, System::Collections::Generic::IEnumerable<System::Linq::Expressions::Expression ^> ^ arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression instance, System.Reflection.MethodInfo method, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression>? arguments);

static member Call : System.Linq.Expressions.Expression * System.Reflection.MethodInfo * seq<System.Linq.Expressions.Expression> -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (instance As Expression, method As MethodInfo, arguments As IEnumerable(Of Expression)) As MethodCallExpression

Parámetros

instance: Expression

Objeto Expression en el que se va a establecer la propiedad Object (pase null para un método static, Shared en Visual Basic).

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

arguments: IEnumerable<Expression>

IEnumerable<T> que contiene los objetos Expression que se van a usar para rellenar la colección de Arguments.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y Object, Method y Arguments se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

o bien

instance es null y method representa un método de instancia.

ArgumentException

instance.Type no se puede asignar al tipo declarativo del método representado por method.

o bien

El número de elementos de arguments no es igual al número de parámetros del método representado por method.

o bien

Uno o varios elementos de arguments no se pueden asignar al parámetro correspondiente del método representado por method.

Comentarios

Para representar una llamada a un static método (Shared en Visual Basic), pase null para el instance parámetro cuando llame a este método o llame Call a en su lugar.

Si method representa un método de instancia, la Type propiedad de instance debe ser asignable al tipo declarativo del método representado por method.

Nota

La Type propiedad del resultado MethodCallExpression es igual al tipo de valor devuelto del método representado por method.

Se aplica a

Call(MethodInfo, Expression[])

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método static (Shared en Visual Basic) con argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Reflection::MethodInfo ^ method, ... cli::array <System::Linq::Expressions::Expression ^> ^ arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, params System.Linq.Expressions.Expression[] arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, params System.Linq.Expressions.Expression[]? arguments);

static member Call : System.Reflection.MethodInfo * System.Linq.Expressions.Expression[] -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (method As MethodInfo, ParamArray arguments As Expression()) As MethodCallExpression

Parámetros

method: MethodInfo

MethodInfo que representa un método static (Shared en Visual Basic) en el que se va a establecer la propiedad Method.

arguments: Expression[]

Matriz de objetos Expression que se va a usar para rellenar la colección de Arguments.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Method y Arguments se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

ArgumentException

El número de elementos de arguments no es igual al número de parámetros del método representado por method.

o bien

Uno o varios elementos de arguments no se pueden asignar al parámetro correspondiente del método representado por method.

Comentarios

Nota

La Type propiedad del resultado MethodCallExpression es igual al tipo de valor devuelto del método representado por method. La propiedad Object es null.

Se aplica a

Call(MethodInfo, Expression)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método static (Shared en Visual Basic) que toma un argumento.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Reflection::MethodInfo ^ method, System::Linq::Expressions::Expression ^ arg0);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0);

static member Call : System.Reflection.MethodInfo * System.Linq.Expressions.Expression -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (method As MethodInfo, arg0 As Expression) As MethodCallExpression

Parámetros

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

arg0: Expression

Expression que representa el primer argumento.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

Ejemplos

En el ejemplo siguiente se muestra cómo crear una expresión que llama a un static método (Shared en Visual Basic) que toma un argumento.

// Add the following directive to your file:
// using System.Linq.Expressions;

public class SampleClass
{
    public static int Increment(int arg1)
    {
        return arg1 + 1;
    }
}

static public void TestCall()
{

    //This expression represents a call to an instance method with one argument.
    Expression callExpr = Expression.Call(
                            typeof(SampleClass).GetMethod("Increment"),
                            Expression.Constant(2)
                        );

    // Print out the expression.
    Console.WriteLine(callExpr.ToString());

    // The following statement first creates an expression tree,
    // then compiles it, and then executes it.
    Console.WriteLine(Expression.Lambda<Func<int>>(callExpr).Compile()());

    // This code example produces the following output:
    //
    // Increment(2)
    // 3
}

' Add the following directive to your file:
' Imports System.Linq.Expressions  

Public Class SampleClass
    Shared Function Increment(ByVal arg1 As Integer) As Integer
        Return arg1 + 1
    End Function
End Class
Shared Sub TestCall()
    'This expression represents a call to an instance method with one argument.
    Dim callExpr As Expression = Expression.Call(
        GetType(SampleClass).GetMethod("Increment"),
        Expression.Constant(2))

    ' Print the expression.
    Console.WriteLine(callExpr.ToString())

    ' The following statement first creates an expression tree,
    ' then compiles it, and then executes it.
    Console.WriteLine(Expression.Lambda(Of Func(Of Integer))(callExpr).Compile()())
End Sub

' This code example produces the following output:
'
' Increment(2)
' 3

Se aplica a

Call(MethodInfo, IEnumerable<Expression>)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método estático (Shared en Visual Basic).

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Reflection::MethodInfo ^ method, System::Collections::Generic::IEnumerable<System::Linq::Expressions::Expression ^> ^ arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> arguments);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression>? arguments);

static member Call : System.Reflection.MethodInfo * seq<System.Linq.Expressions.Expression> -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (method As MethodInfo, arguments As IEnumerable(Of Expression)) As MethodCallExpression

Parámetros

method: MethodInfo

Objeto MethodInfo que representa el método de destino.

arguments: IEnumerable<Expression>

Colección de Expression que representa los argumentos de la llamada.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Se aplica a

Call(Expression, MethodInfo)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método que no toma ningún argumento.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Linq::Expressions::Expression ^ instance, System::Reflection::MethodInfo ^ method);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression instance, System.Reflection.MethodInfo method);

public static System.Linq.Expressions.MethodCallExpression Call (System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method);

static member Call : System.Linq.Expressions.Expression * System.Reflection.MethodInfo -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (instance As Expression, method As MethodInfo) As MethodCallExpression

Parámetros

instance: Expression

Expression que especifica la instancia para una llamada al método de instancia (pasa null para un método static, Shared en Visual Basic).

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

o bien

instance es null y method representa un método de instancia.

ArgumentException

instance.Type no se puede asignar al tipo declarativo del método representado por method.

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear una expresión que llama a un método sin argumentos.

// Add the following directive to your file:
// using System.Linq.Expressions;

// This expression represents a call to an instance method without arguments.
Expression callExpr = Expression.Call(
    Expression.Constant("sample string"), typeof(String).GetMethod("ToUpper", new Type[] { }));

// Print out the expression.
Console.WriteLine(callExpr.ToString());

// The following statement first creates an expression tree,
// then compiles it, and then executes it.
Console.WriteLine(Expression.Lambda<Func<String>>(callExpr).Compile()());

// This code example produces the following output:
//
// "sample string".ToUpper
// SAMPLE STRING

' Add the following directive to your file:
' Imports System.Linq.Expressions   

' This expression represents a call to an instance method without arguments.
Dim callExpr As Expression = Expression.Call(
    Expression.Constant("sample string"), GetType(String).GetMethod("ToUpper", New Type() {}))

' Print the expression.
Console.WriteLine(callExpr.ToString())

' The following statement first creates an expression tree,
' then compiles it, and then executes it.  
Console.WriteLine(Expression.Lambda(Of Func(Of String))(callExpr).Compile()())

' This code example produces the following output:
'
' "sample string".ToUpper
' SAMPLE STRING

Comentarios

Para representar una llamada a un static método (Shared en Visual Basic), pase null para el instance parámetro al llamar a este método.

Si method representa un método de instancia, la Type propiedad de instance debe ser asignable al tipo declarativo del método representado por method.

La Arguments propiedad del resultado MethodCallExpression está vacía. La Type propiedad es igual al tipo de valor devuelto del método representado por method.

Se aplica a

Call(MethodInfo, Expression, Expression)

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Source:: MethodCallExpression.cs

Crea un objeto MethodCallExpression que representa una llamada a un método estático que toma dos argumentos.

public:
 static System::Linq::Expressions::MethodCallExpression ^ Call(System::Reflection::MethodInfo ^ method, System::Linq::Expressions::Expression ^ arg0, System::Linq::Expressions::Expression ^ arg1);

public static System.Linq.Expressions.MethodCallExpression Call (System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1);

static member Call : System.Reflection.MethodInfo * System.Linq.Expressions.Expression * System.Linq.Expressions.Expression -> System.Linq.Expressions.MethodCallExpression

Public Shared Function Call (method As MethodInfo, arg0 As Expression, arg1 As Expression) As MethodCallExpression

Parámetros

method: MethodInfo

MethodInfo en el que se va a establecer la propiedad Method.

arg0: Expression

Expression que representa el primer argumento.

arg1: Expression

Objeto Expression que representa el segundo argumento.

Devoluciones

MethodCallExpression

MethodCallExpression cuya propiedad NodeType es Call y cuyas propiedades Object y Method se establecen en los valores especificados.

Excepciones

ArgumentNullException

method es null.

Se aplica a