Expression.ArrayAccess 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 un objeto IndexExpression para obtener acceso a una matriz.

Sobrecargas

ArrayAccess(Expression, IEnumerable<Expression>)	Crea un objeto IndexExpression para obtener acceso a una matriz multidimensional.
ArrayAccess(Expression, Expression[])	Crea un objeto IndexExpression para obtener acceso a una matriz.

ArrayAccess(Expression, IEnumerable<Expression>)

Source:: IndexExpression.cs

Source:: IndexExpression.cs

Source:: IndexExpression.cs

Crea un objeto IndexExpression para obtener acceso a una matriz multidimensional.

public:
 static System::Linq::Expressions::IndexExpression ^ ArrayAccess(System::Linq::Expressions::Expression ^ array, System::Collections::Generic::IEnumerable<System::Linq::Expressions::Expression ^> ^ indexes);

public static System.Linq.Expressions.IndexExpression ArrayAccess (System.Linq.Expressions.Expression array, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression> indexes);

public static System.Linq.Expressions.IndexExpression ArrayAccess (System.Linq.Expressions.Expression array, System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression>? indexes);

static member ArrayAccess : System.Linq.Expressions.Expression * seq<System.Linq.Expressions.Expression> -> System.Linq.Expressions.IndexExpression

Public Shared Function ArrayAccess (array As Expression, indexes As IEnumerable(Of Expression)) As IndexExpression

Parámetros

array: Expression

Expresión que representa la matriz multidimensional.

indexes: IEnumerable<Expression>

IEnumerable<T> que contiene expresiones usadas para indexar la matriz.

Devoluciones

IndexExpression

Objeto IndexExpression creado.

Ejemplos

En el ejemplo de código siguiente se muestra cómo cambiar el valor de un elemento de una matriz multidimensional 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 two-dimensional array.
ParameterExpression arrayExpr = Expression.Parameter(typeof(int[,]), "Array");

// This parameter expression represents a first array index.
ParameterExpression firstIndexExpr = Expression.Parameter(typeof(int), "FirstIndex");
// This parameter expression represents a second array index.
ParameterExpression secondIndexExpr = Expression.Parameter(typeof(int), "SecondIndex");

// The list of indexes.
List<Expression> indexes = new List<Expression> { firstIndexExpr, secondIndexExpr };

// 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 access operation to a multidimensional array.
// It can be used for assigning to, or reading from, an array element.
Expression arrayAccessExpr = Expression.ArrayAccess(
    arrayExpr,
    indexes
);

// 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, int>> lambdaExpr =
    Expression.Lambda<Func<int[,], int, int, int, int>>(
        Expression.Assign(arrayAccessExpr, Expression.Add(arrayAccessExpr, valueExpr)),
        arrayExpr,
        firstIndexExpr,
        secondIndexExpr,
        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.
int[,] sampleArray = { {10,  20,   30},
                       {100, 200, 300}};
Console.WriteLine(lambdaExpr.Compile().Invoke(sampleArray, 1, 1, 5));

// This code example produces the following output:
//
// Array Access Expression:
// Array[FirstIndex, SecondIndex]

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

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

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

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

' This parameter expression represents a first array index.            
Dim firstIndexExpr As ParameterExpression = Expression.Parameter(GetType(Integer), "FirstIndex")
' This parameter expression represents a second array index.            
Dim secondIndexExpr As ParameterExpression = Expression.Parameter(GetType(Integer), "SecondIndex")

' The list of indexes.
Dim indexes As List(Of Expression) = New List(Of Expression) From
    {firstIndexExpr, secondIndexExpr}

' 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 access operation to a multidimensional array.
' It can be used for assigning to, or reading from, an array element.
Dim arrayAccessExpr As Expression = Expression.ArrayAccess(
    arrayExpr,
    indexes
)

' 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, Integer)) =
    Expression.Lambda(Of Func(Of Integer(,), Integer, Integer, Integer, Integer))(
        Expression.Assign(arrayAccessExpr, Expression.Add(arrayAccessExpr, valueExpr)),
        arrayExpr,
        firstIndexExpr,
        secondIndexExpr,
        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.
Dim sampleArray = {{10, 20, 30},
                       {100, 200, 300}}
Console.WriteLine(lambdaExpr.Compile().Invoke(sampleArray, 1, 1, 5))

' This code example produces the following output:
'
' Array Access Expression:
' Array[FirstIndex, SecondIndex]

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

' The result of executing the lambda expression:
' 205

Comentarios

La expresión que representa la matriz se puede obtener mediante el MakeMemberAccess método , o a través NewArrayBounds de o NewArrayInit.

Se aplica a

ArrayAccess(Expression, Expression[])

Source:: IndexExpression.cs

Source:: IndexExpression.cs

Source:: IndexExpression.cs

Crea un objeto IndexExpression para obtener acceso a una matriz.

public:
 static System::Linq::Expressions::IndexExpression ^ ArrayAccess(System::Linq::Expressions::Expression ^ array, ... cli::array <System::Linq::Expressions::Expression ^> ^ indexes);

public static System.Linq.Expressions.IndexExpression ArrayAccess (System.Linq.Expressions.Expression array, params System.Linq.Expressions.Expression[] indexes);

public static System.Linq.Expressions.IndexExpression ArrayAccess (System.Linq.Expressions.Expression array, params System.Linq.Expressions.Expression[]? indexes);

static member ArrayAccess : System.Linq.Expressions.Expression * System.Linq.Expressions.Expression[] -> System.Linq.Expressions.IndexExpression

Public Shared Function ArrayAccess (array As Expression, ParamArray indexes As Expression()) As IndexExpression

Parámetros

array: Expression

Expresión que representa la matriz para indizar.

indexes: Expression[]

Matriz que contiene expresiones usadas para indizar la matriz.

Devoluciones

IndexExpression

Objeto IndexExpression creado.

Ejemplos

En el ejemplo de código siguiente se muestra cómo 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

Comentarios

La expresión que representa la matriz se puede obtener mediante el MakeMemberAccess método , o a través NewArrayBounds de o NewArrayInit.

Para matrices multidimensionales, use el ArrayAccess método .

Se aplica a

Compartir vía

Expression.ArrayAccess Método

Definición

Sobrecargas

ArrayAccess(Expression, IEnumerable<Expression>)

Parámetros

Devoluciones

Ejemplos

Comentarios

Se aplica a

ArrayAccess(Expression, Expression[])

Parámetros

Devoluciones

Ejemplos

Comentarios

Se aplica a

Recursos adicionales