IndexExpression Clase

Definición

Espacio de nombres:

System.Linq.Expressions

Ensamblado:

System.Core.dll

Representa la indexación de una propiedad o matriz.

public ref class IndexExpression sealed : System::Linq::Expressions::Expression, System::Linq::Expressions::IArgumentProvider

public sealed class IndexExpression : System.Linq.Expressions.Expression, System.Linq.Expressions.IArgumentProvider

type IndexExpression = class
    inherit Expression
    interface IArgumentProvider

Public NotInheritable Class IndexExpression
Inherits Expression
Implements IArgumentProvider

Herencia

Object

Expression

IndexExpression

Implementaciones

IArgumentProvider

Ejemplos

En el ejemplo de código siguiente se muestra cómo crear un objeto del IndexExpression tipo y usarlo para cambiar un valor de un elemento de matriz mediante el ArrayAccess método .

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

// This parameter expression represents a variable that will hold the array.
ParameterExpression arrayExpr = Expression.Parameter(typeof(int[]), "Array");

// This parameter expression represents an array index.
ParameterExpression indexExpr = Expression.Parameter(typeof(int), "Index");

// This parameter represents the value that will be added to a corresponding array element.
ParameterExpression valueExpr = Expression.Parameter(typeof(int), "Value");

// This expression represents an array access operation.
// It can be used for assigning to, or reading from, an array element.
Expression arrayAccessExpr = Expression.ArrayAccess(
    arrayExpr,
    indexExpr
);

// This lambda expression assigns a value provided to it to a specified array element.
// The array, the index of the array element, and the value to be added to the element
// are parameters of the lambda expression.
Expression<Func<int[], int, int, int>> lambdaExpr = Expression.Lambda<Func<int[], int, int, int>>(
    Expression.Assign(arrayAccessExpr, Expression.Add(arrayAccessExpr, valueExpr)),
    arrayExpr,
    indexExpr,
    valueExpr
);

// Print out expressions.
Console.WriteLine("Array Access Expression:");
Console.WriteLine(arrayAccessExpr.ToString());

Console.WriteLine("Lambda Expression:");
Console.WriteLine(lambdaExpr.ToString());

Console.WriteLine("The result of executing the lambda expression:");

// The following statement first creates an expression tree,
// then compiles it, and then executes it.
// Parameters passed to the Invoke method are passed to the lambda expression.
Console.WriteLine(lambdaExpr.Compile().Invoke(new int[] { 10, 20, 30 }, 0, 5));

// This code example produces the following output:
//
// Array Access Expression:
// Array[Index]

// Lambda Expression:
// (Array, Index, Value) => (Array[Index] = (Array[Index] + Value))

// The result of executing the lambda expression:
// 15

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

' This parameter expression represents a variable that will hold the array.
Dim arrayExpr As ParameterExpression = Expression.Parameter(GetType(Integer()), "Array")

' This parameter expression represents an array index.
' For multidimensional arrays, you can define several indexes. 
Dim indexExpr As ParameterExpression = Expression.Parameter(GetType(Integer), "Index")

' This parameter represents the value that will be added to a corresponding array element.
Dim valueExpr As ParameterExpression = Expression.Parameter(GetType(Integer), "Value")

' This expression represents an array access operation.
' It can be used for assigning to, or reading from, an array element.
Dim arrayAccessExpr As Expression = Expression.ArrayAccess(
    arrayExpr,
    indexExpr
)

' This lambda expression assigns a value provided to it to a specified array element.
' The array, the index of the array element, and the value to be added to the element
' are parameters of the lambda expression.
Dim lambdaExpr As Expression(Of Func(Of Integer(), Integer, Integer, Integer)) =
    Expression.Lambda(Of Func(Of Integer(), Integer, Integer, Integer))(
        Expression.Assign(arrayAccessExpr, Expression.Add(arrayAccessExpr, valueExpr)),
    arrayExpr,
    indexExpr,
    valueExpr
  )

' Print expressions.
Console.WriteLine("Array Access Expression:")
Console.WriteLine(arrayAccessExpr.ToString())

Console.WriteLine("Lambda Expression:")
Console.WriteLine(lambdaExpr.ToString())

Console.WriteLine("The result of executing the lambda expression:")

' The following statement first creates an expression tree,
' then compiles it, and then executes it.
' Parameters passed to the Invoke method are passed to the lambda expression.
Console.WriteLine(lambdaExpr.Compile().Invoke(New Integer() {10, 20, 30}, 0, 5))

' This code example produces the following output:
'
' Array Access Expression:
' Array[Index]

' Lambda Expression:
' (Array, Index, Value) => (Array[Index] = (Array[Index] + Value))

' The result of executing the lambda expression:
' 15

Propiedades

Nombre	Description
Arguments	Obtiene los argumentos que se usarán para indexar la propiedad o matriz.
CanReduce	Indica que el nodo se puede reducir a un nodo más sencillo. Si devuelve true, se puede llamar a Reduce() para generar el formulario reducido. (Heredado de Expression)
Indexer	Obtiene para PropertyInfo la propiedad si la expresión representa una propiedad indizada, devuelve null de lo contrario.
NodeType	Devuelve el tipo de nodo de este Expression.
Object	Objeto que se va a indexar.
Type	Obtiene el tipo estático de la expresión que Expression representa.

Métodos

Nombre	Description
Accept(ExpressionVisitor)	Envía al método de visita específico para este tipo de nodo. Por ejemplo, MethodCallExpression llama a VisitMethodCall(MethodCallExpression). (Heredado de Expression)
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
GetHashCode()	Actúa como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
Reduce()	Reduce este nodo a una expresión más sencilla. Si CanReduce devuelve true, debe devolver una expresión válida. Este método puede devolver otro nodo que se debe reducir. (Heredado de Expression)
ReduceAndCheck()	Reduce este nodo a una expresión más sencilla. Si CanReduce devuelve true, debe devolver una expresión válida. Este método puede devolver otro nodo que se debe reducir. (Heredado de Expression)
ReduceExtensions()	Reduce la expresión a un tipo de nodo conocido (que no es un nodo de extensión) o simplemente devuelve la expresión si ya es un tipo conocido. (Heredado de Expression)
ToString()	Devuelve una representación textual de .Expression (Heredado de Expression)
Update(Expression, IEnumerable<Expression>)	Crea una nueva expresión similar a esta, pero que usa los elementos secundarios proporcionados. Si todos los elementos secundarios son iguales, devolverá esta expresión.
VisitChildren(ExpressionVisitor)	Reduce el nodo y, a continuación, llama al delegado de visitante en la expresión reducida. El método produce una excepción si el nodo no se puede deducir. (Heredado de Expression)

Implementaciones de interfaz explícitas

Nombre	Description
IArgumentProvider.ArgumentCount	Devuelve el número de argumentos al nodo de árbol de expresión. No debe usar este miembro. Solo es público debido a la refactorización de ensamblados y se usa internamente para las optimizaciones de rendimiento.
IArgumentProvider.GetArgument(Int32)	Devuelve el argumento en el índice, lo que produce si el índice está fuera de los límites. No debe usar este miembro. Solo es público debido a la refactorización de ensamblados y se usa internamente para las optimizaciones de rendimiento.