IndexExpression Klasse

Definition

Stellt die Indizierung einer Eigenschaft oder eines Arrays dar.Represents indexing a property or array.

public ref class IndexExpression sealed : System::Linq::Expressions::Expression, System::Linq::Expressions::IArgumentProvider
public ref class IndexExpression sealed : System::Linq::Expressions::Expression
public sealed class IndexExpression : System.Linq.Expressions.Expression, System.Linq.Expressions.IArgumentProvider
public sealed class IndexExpression : System.Linq.Expressions.Expression
type IndexExpression = class
    inherit Expression
    interface IArgumentProvider
type IndexExpression = class
    inherit Expression
Public NotInheritable Class IndexExpression
Inherits Expression
Implements IArgumentProvider
Public NotInheritable Class IndexExpression
Inherits Expression
Vererbung
IndexExpression
Implementiert

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie ein Objekt des- IndexExpression Typs erstellt und zum Ändern eines Werts eines Array Elements mithilfe der-Methode verwendet wird ArrayAccess .The following code example shows how to create an object of the IndexExpression type and use it to change a value of an array element by using the ArrayAccess method.

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

Eigenschaften

Arguments

Ruft die Argumente ab, die zum Indizieren der Eigenschaft oder des Arrays verwendet werden.Gets the arguments that will be used to index the property or array.

CanReduce

Gibt an, dass der Knoten zu einem einfacheren Knoten reduziert werden kann.Indicates that the node can be reduced to a simpler node. Wenn true zurückgegeben wird, kann Reduce() aufgerufen werden, um das reduzierte Formular zu erzeugen.If this returns true, Reduce() can be called to produce the reduced form.

(Geerbt von Expression)
Indexer

Ruft die PropertyInfo für die Eigenschaft ab, wenn der Ausdruck eine indizierte Eigenschaft darstellt. Gibt andernfalls "null" zurück.Gets the PropertyInfo for the property if the expression represents an indexed property, returns null otherwise.

NodeType

Gibt den Knotentyp dieses Expression zurück.Returns the node type of this Expression.

Object

Ein zu indizierendes Objekt.An object to index.

Type

Ruft den statischen Typ des Ausdrucks ab, den dieser Expression darstellt.Gets the static type of the expression that this Expression represents.

Methoden

Accept(ExpressionVisitor)

Sendet an die spezifische Visit-Methode für diesen Knotentyp.Dispatches to the specific visit method for this node type. Beispielsweise ruft MethodCallExpression die Methode VisitMethodCall(MethodCallExpression) auf.For example, MethodCallExpression calls the VisitMethodCall(MethodCallExpression).

(Geerbt von Expression)
Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
Reduce()

Reduziert diesen Knoten zu einem einfacheren Ausdruck.Reduces this node to a simpler expression. Wenn CanReduce true zurückgibt, sollte ein gültiger Ausdruck zurückgegeben werden.If CanReduce returns true, this should return a valid expression. Diese Methode kann einen anderen Knoten zurückgeben, der selbst reduziert werden muss.This method can return another node which itself must be reduced.

(Geerbt von Expression)
ReduceAndCheck()

Reduziert diesen Knoten zu einem einfacheren Ausdruck.Reduces this node to a simpler expression. Wenn CanReduce true zurückgibt, sollte ein gültiger Ausdruck zurückgegeben werden.If CanReduce returns true, this should return a valid expression. Diese Methode kann einen anderen Knoten zurückgeben, der selbst reduziert werden muss.This method can return another node which itself must be reduced.

(Geerbt von Expression)
ReduceExtensions()

Reduziert den Ausdruck zu einem bekannten Knotentyp (kein Erweiterungsknoten) oder gibt nur den Ausdruck zurück, wenn es sich um einen bereits bekannten Typ handelt.Reduces the expression to a known node type (that is not an Extension node) or just returns the expression if it is already a known type.

(Geerbt von Expression)
ToString()

Gibt eine Textdarstellung des Expression zurück.Returns a textual representation of the Expression.

(Geerbt von Expression)
Update(Expression, IEnumerable<Expression>)

Erstellt einen neuen Ausdruck, der diesem ähnelt, verwendet jedoch die angegebenen untergeordneten Elemente.Creates a new expression that is like this one, but using the supplied children. Wenn alle untergeordneten Elemente identisch sind, wird dieser Ausdruck zurückgegeben.If all of the children are the same, it will return this expression.

VisitChildren(ExpressionVisitor)

Reduziert den Knoten und ruft dann den Visitor-Delegaten für den reduzierten Ausdruck auf.Reduces the node and then calls the visitor delegate on the reduced expression. Die Methode löst eine Ausnahme aus, wenn der Knoten nicht reduziert werden kann.The method throws an exception if the node is not reducible.

(Geerbt von Expression)

Explizite Schnittstellenimplementierungen

IArgumentProvider.ArgumentCount

Gibt die Anzahl der Argumente für den Ausdrucksstrukturknoten zurück.Returns the number of arguments to the expression tree node. Sie sollten diesen Member nicht verwenden.You should not use this member. Es ist nur aufgrund der Assemblyumgestaltung öffentlich und wird intern zur Leistungsoptimierung verwendet.It is only public due to assembly refactoring, and it is used internally for performance optimizations.

IArgumentProvider.GetArgument(Int32)

Gibt das Argument bei Index zurück, das ausgelöst wird, wenn der Index außerhalb des gültigen Bereichs liegt.Returns the argument at index, throwing if index is out of bounds. Sie sollten diesen Member nicht verwenden.You should not use this member. Es ist nur aufgrund der Assemblyumgestaltung öffentlich und wird intern zur Leistungsoptimierung verwendet.It is only public due to assembly refactoring, and it is used internally for performance optimizations.

Gilt für: