Expression.ArrayAccess Method (Expression, array<Expression[])

Parameters

• array
  Type: System.Linq.Expressions.Expression
  An expression representing the array to index.

• indexes
  Type: array<System.Linq.Expressions.Expression[]
  An array that contains expressions used to index the array.

Return Value

Type: System.Linq.Expressions.IndexExpression
The created IndexExpression.

' 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.
outputBlock.Text &= "Array Access Expression:" & vbCrLf
outputBlock.Text &= arrayAccessExpr.ToString() & vbCrLf

outputBlock.Text &= "Lambda Expression:" & vbCrLf
outputBlock.Text &= lambdaExpr.ToString() & vbCrLf

outputBlock.Text &= "The result of executing the lambda expression:" & vbCrLf

' 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.
outputBlock.Text &= lambdaExpr.Compile().Invoke(New Integer() {10, 20, 30}, 0, 5) & vbCrLf

' 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:
       // 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.
       outputBlock.Text += "Array Access Expression:" + "\n";
       outputBlock.Text += arrayAccessExpr.ToString() + "\n";

       outputBlock.Text += "Lambda Expression:" + "\n";
       outputBlock.Text += lambdaExpr.ToString() + "\n";

       outputBlock.Text += "The result of executing the lambda expression:" + "\n";

       // 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.
       outputBlock.Text += lambdaExpr.Compile().Invoke(new int[] { 10, 20, 30 }, 0, 5) + "\n";

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