AggregateExpression AggregateExpression Class

Base class for aggregate expressions.

Syntax

Declaration

public abstract class AggregateExpression : ExpressionPublic MustInherit Class AggregateExpression
    Inherits Expression

Inheritance Hierarchy

System.Object

System.Object
System.Linq.Expressions.Expression

System.Linq.Expressions.Expression
AggregateExpression

AggregateExpression

Inherited Members

Assign(Expression, Expression),

MakeBinary(ExpressionType, Expression, Expression),

MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo),

MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression),

Equal(Expression, Expression),

Equal(Expression, Expression, Boolean, MethodInfo),

ReferenceEqual(Expression, Expression),

NotEqual(Expression, Expression),

NotEqual(Expression, Expression, Boolean, MethodInfo),

ReferenceNotEqual(Expression, Expression),

GreaterThan(Expression, Expression),

GreaterThan(Expression, Expression, Boolean, MethodInfo),

LessThan(Expression, Expression),

LessThan(Expression, Expression, Boolean, MethodInfo),

GreaterThanOrEqual(Expression, Expression),

GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo),

LessThanOrEqual(Expression, Expression),

LessThanOrEqual(Expression, Expression, Boolean, MethodInfo),

AndAlso(Expression, Expression),

AndAlso(Expression, Expression, MethodInfo),

OrElse(Expression, Expression),

OrElse(Expression, Expression, MethodInfo),

Coalesce(Expression, Expression),

Coalesce(Expression, Expression, LambdaExpression),

Add(Expression, Expression),

Add(Expression, Expression, MethodInfo),

AddAssign(Expression, Expression),

AddAssign(Expression, Expression, MethodInfo),

AddAssign(Expression, Expression, MethodInfo, LambdaExpression),

AddAssignChecked(Expression, Expression),

AddAssignChecked(Expression, Expression, MethodInfo),

AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression),

AddChecked(Expression, Expression),

AddChecked(Expression, Expression, MethodInfo),

Subtract(Expression, Expression),

Subtract(Expression, Expression, MethodInfo),

SubtractAssign(Expression, Expression),

SubtractAssign(Expression, Expression, MethodInfo),

SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression),

SubtractAssignChecked(Expression, Expression),

SubtractAssignChecked(Expression, Expression, MethodInfo),

SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression),

SubtractChecked(Expression, Expression),

SubtractChecked(Expression, Expression, MethodInfo),

Divide(Expression, Expression),

Divide(Expression, Expression, MethodInfo),

DivideAssign(Expression, Expression),

DivideAssign(Expression, Expression, MethodInfo),

DivideAssign(Expression, Expression, MethodInfo, LambdaExpression),

Modulo(Expression, Expression),

Modulo(Expression, Expression, MethodInfo),

ModuloAssign(Expression, Expression),

ModuloAssign(Expression, Expression, MethodInfo),

ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression),

Multiply(Expression, Expression),

Multiply(Expression, Expression, MethodInfo),

MultiplyAssign(Expression, Expression),

MultiplyAssign(Expression, Expression, MethodInfo),

MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression),

MultiplyAssignChecked(Expression, Expression),

MultiplyAssignChecked(Expression, Expression, MethodInfo),

MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression),

MultiplyChecked(Expression, Expression),

MultiplyChecked(Expression, Expression, MethodInfo),

LeftShift(Expression, Expression),

LeftShift(Expression, Expression, MethodInfo),

LeftShiftAssign(Expression, Expression),

LeftShiftAssign(Expression, Expression, MethodInfo),

LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression),

RightShift(Expression, Expression),

RightShift(Expression, Expression, MethodInfo),

RightShiftAssign(Expression, Expression),

RightShiftAssign(Expression, Expression, MethodInfo),

RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression),

And(Expression, Expression),

And(Expression, Expression, MethodInfo),

AndAssign(Expression, Expression),

AndAssign(Expression, Expression, MethodInfo),

AndAssign(Expression, Expression, MethodInfo, LambdaExpression),

Or(Expression, Expression),

Or(Expression, Expression, MethodInfo),

OrAssign(Expression, Expression),

OrAssign(Expression, Expression, MethodInfo),

OrAssign(Expression, Expression, MethodInfo, LambdaExpression),

ExclusiveOr(Expression, Expression),

ExclusiveOr(Expression, Expression, MethodInfo),

ExclusiveOrAssign(Expression, Expression),

ExclusiveOrAssign(Expression, Expression, MethodInfo),

ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression),

Power(Expression, Expression),

Power(Expression, Expression, MethodInfo),

PowerAssign(Expression, Expression),

PowerAssign(Expression, Expression, MethodInfo),

PowerAssign(Expression, Expression, MethodInfo, LambdaExpression),

ArrayIndex(Expression, Expression),

Block(Expression, Expression),

Block(Expression, Expression, Expression),

Block(Expression, Expression, Expression, Expression),

Block(Expression, Expression, Expression, Expression, Expression),

Block(Expression[]),

Block(Expression()),

Block(IEnumerable<Expression>),

Block(IEnumerable(Of Expression)),

Block(Type, Expression[]),

Block(Type, Expression()),

Block(Type, IEnumerable<Expression>),

Block(Type, IEnumerable(Of Expression)),

Block(IEnumerable<ParameterExpression>, Expression[]),

Block(IEnumerable(Of ParameterExpression), Expression()),

Block(Type, IEnumerable<ParameterExpression>, Expression[]),

Block(Type, IEnumerable(Of ParameterExpression), Expression()),

Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>),

Block(IEnumerable(Of ParameterExpression), IEnumerable(Of Expression)),

Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>),

Block(Type, IEnumerable(Of ParameterExpression), IEnumerable(Of Expression)),

Catch(Type, Expression),

Catch(ParameterExpression, Expression),

Catch(Type, Expression, Expression),

Catch(ParameterExpression, Expression, Expression),

MakeCatchBlock(Type, ParameterExpression, Expression, Expression),

Condition(Expression, Expression, Expression),

Condition(Expression, Expression, Expression, Type),

IfThen(Expression, Expression),

IfThenElse(Expression, Expression, Expression),

Constant(Object),

Constant(Object, Type),

DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32),

ClearDebugInfo(SymbolDocumentInfo),

Empty(),

Default(Type),

MakeDynamic(Type, CallSiteBinder, Expression[]),

MakeDynamic(Type, CallSiteBinder, Expression()),

MakeDynamic(Type, CallSiteBinder, IEnumerable<Expression>),

MakeDynamic(Type, CallSiteBinder, IEnumerable(Of Expression)),

MakeDynamic(Type, CallSiteBinder, Expression),

MakeDynamic(Type, CallSiteBinder, Expression, Expression),

MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression),

MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression, Expression),

Dynamic(CallSiteBinder, Type, Expression[]),

Dynamic(CallSiteBinder, Type, Expression()),

Dynamic(CallSiteBinder, Type, Expression),

Dynamic(CallSiteBinder, Type, Expression, Expression),

Dynamic(CallSiteBinder, Type, Expression, Expression, Expression),

Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression),

Dynamic(CallSiteBinder, Type, IEnumerable<Expression>),

Dynamic(CallSiteBinder, Type, IEnumerable(Of Expression)),

ElementInit(MethodInfo, Expression[]),

ElementInit(MethodInfo, Expression()),

ElementInit(MethodInfo, IEnumerable<Expression>),

ElementInit(MethodInfo, IEnumerable(Of Expression)),

Reduce(),

Accept(ExpressionVisitor),

ReduceAndCheck(),

ReduceExtensions(),

ToString(),

Break(LabelTarget),

Break(LabelTarget, Expression),

Break(LabelTarget, Type),

Break(LabelTarget, Expression, Type),

Continue(LabelTarget),

Continue(LabelTarget, Type),

Return(LabelTarget),

Return(LabelTarget, Type),

Return(LabelTarget, Expression),

Return(LabelTarget, Expression, Type),

Goto(LabelTarget),

Goto(LabelTarget, Type),

Goto(LabelTarget, Expression),

Goto(LabelTarget, Expression, Type),

MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type),

MakeIndex(Expression, PropertyInfo, IEnumerable<Expression>),

MakeIndex(Expression, PropertyInfo, IEnumerable(Of Expression)),

ArrayAccess(Expression, Expression[]),

ArrayAccess(Expression, Expression()),

ArrayAccess(Expression, IEnumerable<Expression>),

ArrayAccess(Expression, IEnumerable(Of Expression)),

Property(Expression, String, Expression[]),

Property(Expression, String, Expression()),

Property(Expression, PropertyInfo, Expression[]),

Property(Expression, PropertyInfo, Expression()),

Property(Expression, PropertyInfo, IEnumerable<Expression>),

Property(Expression, PropertyInfo, IEnumerable(Of Expression)),

Invoke(Expression, Expression[]),

Invoke(Expression, Expression()),

Invoke(Expression, IEnumerable<Expression>),

Invoke(Expression, IEnumerable(Of Expression)),

Label(LabelTarget),

Label(LabelTarget, Expression),

Label(),

Label(String),

Label(Type),

Label(Type, String),

Lambda<TDelegate>(Expression, ParameterExpression[]),

Lambda(Of TDelegate)(Expression, ParameterExpression()),

Lambda<TDelegate>(Expression, Boolean, ParameterExpression[]),

Lambda(Of TDelegate)(Expression, Boolean, ParameterExpression()),

Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>),

Lambda(Of TDelegate)(Expression, IEnumerable(Of ParameterExpression)),

Lambda<TDelegate>(Expression, Boolean, IEnumerable<ParameterExpression>),

Lambda(Of TDelegate)(Expression, Boolean, IEnumerable(Of ParameterExpression)),

Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>),

Lambda(Of TDelegate)(Expression, String, IEnumerable(Of ParameterExpression)),

Lambda<TDelegate>(Expression, String, Boolean, IEnumerable<ParameterExpression>),

Lambda(Of TDelegate)(Expression, String, Boolean, IEnumerable(Of ParameterExpression)),

Lambda(Expression, ParameterExpression[]),

Lambda(Expression, ParameterExpression()),

Lambda(Expression, Boolean, ParameterExpression[]),

Lambda(Expression, Boolean, ParameterExpression()),

Lambda(Expression, IEnumerable<ParameterExpression>),

Lambda(Expression, IEnumerable(Of ParameterExpression)),

Lambda(Expression, Boolean, IEnumerable<ParameterExpression>),

Lambda(Expression, Boolean, IEnumerable(Of ParameterExpression)),

Lambda(Type, Expression, ParameterExpression[]),

Lambda(Type, Expression, ParameterExpression()),

Lambda(Type, Expression, Boolean, ParameterExpression[]),

Lambda(Type, Expression, Boolean, ParameterExpression()),

Lambda(Type, Expression, IEnumerable<ParameterExpression>),

Lambda(Type, Expression, IEnumerable(Of ParameterExpression)),

Lambda(Type, Expression, Boolean, IEnumerable<ParameterExpression>),

Lambda(Type, Expression, Boolean, IEnumerable(Of ParameterExpression)),

Lambda(Expression, String, IEnumerable<ParameterExpression>),

Lambda(Expression, String, IEnumerable(Of ParameterExpression)),

Lambda(Expression, String, Boolean, IEnumerable<ParameterExpression>),

Lambda(Expression, String, Boolean, IEnumerable(Of ParameterExpression)),

Lambda(Type, Expression, String, IEnumerable<ParameterExpression>),

Lambda(Type, Expression, String, IEnumerable(Of ParameterExpression)),

Lambda(Type, Expression, String, Boolean, IEnumerable<ParameterExpression>),

Lambda(Type, Expression, String, Boolean, IEnumerable(Of ParameterExpression)),

GetFuncType(Type[]),

GetFuncType(Type()),

TryGetFuncType(Type[], Type),

TryGetFuncType(Type(), Type),

GetActionType(Type[]),

GetActionType(Type()),

TryGetActionType(Type[], Type),

TryGetActionType(Type(), Type),

GetDelegateType(Type[]),

GetDelegateType(Type()),

ListInit(NewExpression, Expression[]),

ListInit(NewExpression, Expression()),

ListInit(NewExpression, IEnumerable<Expression>),

ListInit(NewExpression, IEnumerable(Of Expression)),

ListInit(NewExpression, MethodInfo, Expression[]),

ListInit(NewExpression, MethodInfo, Expression()),

ListInit(NewExpression, MethodInfo, IEnumerable<Expression>),

ListInit(NewExpression, MethodInfo, IEnumerable(Of Expression)),

ListInit(NewExpression, ElementInit[]),

ListInit(NewExpression, ElementInit()),

ListInit(NewExpression, IEnumerable<ElementInit>),

ListInit(NewExpression, IEnumerable(Of ElementInit)),

Loop(Expression),

Loop(Expression, LabelTarget),

Loop(Expression, LabelTarget, LabelTarget),

Bind(MemberInfo, Expression),

Bind(MethodInfo, Expression),

Field(Expression, FieldInfo),

Field(Expression, String),

Field(Expression, Type, String),

Property(Expression, String),

Property(Expression, Type, String),

Property(Expression, PropertyInfo),

Property(Expression, MethodInfo),

PropertyOrField(Expression, String),

MakeMemberAccess(Expression, MemberInfo),

MemberInit(NewExpression, MemberBinding[]),

MemberInit(NewExpression, MemberBinding()),

MemberInit(NewExpression, IEnumerable<MemberBinding>),

MemberInit(NewExpression, IEnumerable(Of MemberBinding)),

ListBind(MemberInfo, ElementInit[]),

ListBind(MemberInfo, ElementInit()),

ListBind(MemberInfo, IEnumerable<ElementInit>),

ListBind(MemberInfo, IEnumerable(Of ElementInit)),

ListBind(MethodInfo, ElementInit[]),

ListBind(MethodInfo, ElementInit()),

ListBind(MethodInfo, IEnumerable<ElementInit>),

ListBind(MethodInfo, IEnumerable(Of ElementInit)),

MemberBind(MemberInfo, MemberBinding[]),

MemberBind(MemberInfo, MemberBinding()),

MemberBind(MemberInfo, IEnumerable<MemberBinding>),

MemberBind(MemberInfo, IEnumerable(Of MemberBinding)),

MemberBind(MethodInfo, MemberBinding[]),

MemberBind(MethodInfo, MemberBinding()),

MemberBind(MethodInfo, IEnumerable<MemberBinding>),

MemberBind(MethodInfo, IEnumerable(Of MemberBinding)),

Call(MethodInfo, Expression),

Call(MethodInfo, Expression, Expression),

Call(MethodInfo, Expression, Expression, Expression),

Call(MethodInfo, Expression, Expression, Expression, Expression),

Call(MethodInfo, Expression, Expression, Expression, Expression, Expression),

Call(MethodInfo, Expression[]),

Call(MethodInfo, Expression()),

Call(MethodInfo, IEnumerable<Expression>),

Call(MethodInfo, IEnumerable(Of Expression)),

Call(Expression, MethodInfo),

Call(Expression, MethodInfo, Expression[]),

Call(Expression, MethodInfo, Expression()),

Call(Expression, MethodInfo, Expression, Expression),

Call(Expression, MethodInfo, Expression, Expression, Expression),

Call(Expression, String, Type[], Expression[]),

Call(Expression, String, Type(), Expression()),

Call(Type, String, Type[], Expression[]),

Call(Type, String, Type(), Expression()),

Call(Expression, MethodInfo, IEnumerable<Expression>),

Call(Expression, MethodInfo, IEnumerable(Of Expression)),

ArrayIndex(Expression, Expression[]),

ArrayIndex(Expression, Expression()),

ArrayIndex(Expression, IEnumerable<Expression>),

ArrayIndex(Expression, IEnumerable(Of Expression)),

NewArrayInit(Type, Expression[]),

NewArrayInit(Type, Expression()),

NewArrayInit(Type, IEnumerable<Expression>),

NewArrayInit(Type, IEnumerable(Of Expression)),

NewArrayBounds(Type, Expression[]),

NewArrayBounds(Type, Expression()),

NewArrayBounds(Type, IEnumerable<Expression>),

NewArrayBounds(Type, IEnumerable(Of Expression)),

New(ConstructorInfo),

New(ConstructorInfo, Expression[]),

New(ConstructorInfo, Expression()),

New(ConstructorInfo, IEnumerable<Expression>),

New(ConstructorInfo, IEnumerable(Of Expression)),

New(ConstructorInfo, IEnumerable<Expression>, IEnumerable<MemberInfo>),

New(ConstructorInfo, IEnumerable(Of Expression), IEnumerable(Of MemberInfo)),

New(ConstructorInfo, IEnumerable<Expression>, MemberInfo[]),

New(ConstructorInfo, IEnumerable(Of Expression), MemberInfo()),

New(Type),

Parameter(Type),

Variable(Type),

Parameter(Type, String),

Variable(Type, String),

RuntimeVariables(ParameterExpression[]),

RuntimeVariables(ParameterExpression()),

RuntimeVariables(IEnumerable<ParameterExpression>),

RuntimeVariables(IEnumerable(Of ParameterExpression)),

SwitchCase(Expression, Expression[]),

SwitchCase(Expression, Expression()),

SwitchCase(Expression, IEnumerable<Expression>),

SwitchCase(Expression, IEnumerable(Of Expression)),

Switch(Expression, SwitchCase[]),

Switch(Expression, SwitchCase()),

Switch(Expression, Expression, SwitchCase[]),

Switch(Expression, Expression, SwitchCase()),

Switch(Expression, Expression, MethodInfo, SwitchCase[]),

Switch(Expression, Expression, MethodInfo, SwitchCase()),

Switch(Type, Expression, Expression, MethodInfo, SwitchCase[]),

Switch(Type, Expression, Expression, MethodInfo, SwitchCase()),

Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>),

Switch(Expression, Expression, MethodInfo, IEnumerable(Of SwitchCase)),

Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>),

Switch(Type, Expression, Expression, MethodInfo, IEnumerable(Of SwitchCase)),

SymbolDocument(String),

SymbolDocument(String, Guid),

SymbolDocument(String, Guid, Guid),

SymbolDocument(String, Guid, Guid, Guid),

TryFault(Expression, Expression),

TryFinally(Expression, Expression),

TryCatch(Expression, CatchBlock[]),

TryCatch(Expression, CatchBlock()),

TryCatchFinally(Expression, Expression, CatchBlock[]),

TryCatchFinally(Expression, Expression, CatchBlock()),

MakeTry(Type, Expression, Expression, Expression, IEnumerable<CatchBlock>),

MakeTry(Type, Expression, Expression, Expression, IEnumerable(Of CatchBlock)),

TypeIs(Expression, Type),

TypeEqual(Expression, Type),

MakeUnary(ExpressionType, Expression, Type),

MakeUnary(ExpressionType, Expression, Type, MethodInfo),

Negate(Expression),

Negate(Expression, MethodInfo),

UnaryPlus(Expression),

UnaryPlus(Expression, MethodInfo),

NegateChecked(Expression),

NegateChecked(Expression, MethodInfo),

Not(Expression),

Not(Expression, MethodInfo),

IsFalse(Expression),

IsFalse(Expression, MethodInfo),

IsTrue(Expression),

IsTrue(Expression, MethodInfo),

OnesComplement(Expression),

OnesComplement(Expression, MethodInfo),

TypeAs(Expression, Type),

Unbox(Expression, Type),

Convert(Expression, Type),

Convert(Expression, Type, MethodInfo),

ConvertChecked(Expression, Type),

ConvertChecked(Expression, Type, MethodInfo),

ArrayLength(Expression),

Quote(Expression),

Rethrow(),

Rethrow(Type),

Throw(Expression),

Throw(Expression, Type),

Increment(Expression),

Increment(Expression, MethodInfo),

Decrement(Expression),

Decrement(Expression, MethodInfo),

PreIncrementAssign(Expression),

PreIncrementAssign(Expression, MethodInfo),

PreDecrementAssign(Expression),

PreDecrementAssign(Expression, MethodInfo),

PostIncrementAssign(Expression),

PostIncrementAssign(Expression, MethodInfo),

PostDecrementAssign(Expression),

PostDecrementAssign(Expression, MethodInfo),

CanReduce,

Equals(Object),

Equals(Object, Object),

ReferenceEquals(Object, Object),

GetHashCode(),

GetType(),

MemberwiseClone()

Constructors summary

AggregateExpression(Expression)

Specialised constructor for use only by derived class.

Properties summary

Expression Expression	The expression to aggregate.
NodeType NodeType	Returns the node type of this Expression. (Inherited from Expression.)
Type Type	Gets the static type of the expression that this Expression represents. (Inherited from Expression.)

Methods summary

VisitChildren(ExpressionVisitor)

Reduces the node and then calls the System.Linq.Expressions.ExpressionVisitor.Visit(System.Linq.Expressions.Expression) method passing the reduced expression. Throws an exception if the node isn't reducible.

AggregateExpression(Expression)

AggregateExpression(Expression)

Specialised constructor for use only by derived class.
```
protected AggregateExpression(Expression expression)Protected Sub New(expression As Expression)
```
Parameters
- expression
  
  System.Linq.Expressions.Expression
  
  System.Linq.Expressions.Expression
  
  The expression to aggregate.

Expression

Expression

The expression to aggregate.
```
public virtual Expression Expression { get; }Public Overridable ReadOnly Property Expression As Expression
```
Property Value
- System.Linq.Expressions.Expression
  
  System.Linq.Expressions.Expression
NodeType

NodeType

Returns the node type of this Expression. (Inherited from Expression.)
```
public override ExpressionType NodeType { get; }Public Overrides ReadOnly Property NodeType As ExpressionType
```
Property Value
- System.Linq.Expressions.ExpressionType
  
  System.Linq.Expressions.ExpressionType
  
  The System.Linq.Expressions.ExpressionType that represents this expression.
Type

Type

Gets the static type of the expression that this Expression represents. (Inherited from Expression.)
```
public override Type Type { get; }Public Overrides ReadOnly Property Type As Type
```
Property Value
- System.Type
  
  System.Type
  
  The Type that represents the static type of the expression.

VisitChildren(ExpressionVisitor)

VisitChildren(ExpressionVisitor)

Reduces the node and then calls the System.Linq.Expressions.ExpressionVisitor.Visit(System.Linq.Expressions.Expression) method passing the reduced expression. Throws an exception if the node isn't reducible.
```
protected override Expression VisitChildren(ExpressionVisitor visitor)Protected Overrides Function VisitChildren(visitor As ExpressionVisitor) As Expression
```
Parameters
- visitor
  
  System.Linq.Expressions.ExpressionVisitor
  
  System.Linq.Expressions.ExpressionVisitor
  
  An instance of System.Linq.Expressions.ExpressionVisitor.
Returns
- System.Linq.Expressions.Expression
  
  System.Linq.Expressions.Expression
  
  The expression being visited, or an expression which should replace it in the tree.
Remarks

Override this method to provide logic to walk the node's children. A typical implementation will call visitor.Visit on each of its children, and if any of them change, should return a new copy of itself with the modified children.

Details

Assembly

Microsoft.EntityFrameworkCore.Relational.dll

+ Options

AggregateExpression AggregateExpression Class

Syntax

Declaration

Inheritance Hierarchy

Inherited Members

Constructors summary

Properties summary

Methods summary

Parameters

Property Value

Property Value

Property Value

Parameters

Returns

Remarks

Details

Assembly