Expression.ArrayAccess Method (Expression, IEnumerable<Expression>)

Parameters

• array
  Type: System.Linq.Expressions.Expression
  An expression that represents the multidimensional array.

• indexes
  Type: System.Collections.Generic.IEnumerable<Expression>
  An IEnumerable<T> containing 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 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.
        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.
        Dim sampleArray = {{10, 20, 30},
                               {100, 200, 300}}
        outputBlock.Text &= lambdaExpr.Compile().Invoke(sampleArray, 1, 1, 5) & vbCrLf

        ' 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:
       // 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.
       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.
       int[,] sampleArray = { {10,  20,   30},
                                 {100, 200, 300}};
       outputBlock.Text += lambdaExpr.Compile().Invoke(sampleArray, 1, 1, 5) + "\n";

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