Expression Klass

Definition

Namnområde:
System.Linq.Expressions
Sammansättningar:
System.Core.dll, System.Linq.Expressions.dll
Sammansättning:
System.Core.dll
Sammansättning:
System.Linq.Expressions.dll
Sammansättning:
netstandard.dll

Tillhandahåller basklassen som klasserna som representerar uttrycksträdnoder härleds från. Den innehåller även static (Shared i Visual Basic) fabriksmetoder för att skapa de olika nodtyperna. Det här är en abstract klass.

public ref class Expression abstract
public abstract class Expression
type Expression = class
Public MustInherit Class Expression
Arv
Object
Expression
Härledda

Exempel

I följande kodexempel visas hur du skapar ett blockuttryck. Blockuttrycket består av två MethodCallExpression objekt och ett ConstantExpression objekt.

// Add the following directive to your file:
// using System.Linq.Expressions;

// The block expression allows for executing several expressions sequentually.
// When the block expression is executed,
// it returns the value of the last expression in the sequence.
BlockExpression blockExpr = Expression.Block(
    Expression.Call(
        null,
        typeof(Console).GetMethod("Write", new Type[] { typeof(String) }),
        Expression.Constant("Hello ")
       ),
    Expression.Call(
        null,
        typeof(Console).GetMethod("WriteLine", new Type[] { typeof(String) }),
        Expression.Constant("World!")
        ),
    Expression.Constant(42)
);

Console.WriteLine("The result of executing the expression tree:");
// The following statement first creates an expression tree,
// then compiles it, and then executes it.
var result = Expression.Lambda<Func<int>>(blockExpr).Compile()();

// Print out the expressions from the block expression.
Console.WriteLine("The expressions from the block expression:");
foreach (var expr in blockExpr.Expressions)
    Console.WriteLine(expr.ToString());

// Print out the result of the tree execution.
Console.WriteLine("The return value of the block expression:");
Console.WriteLine(result);

// This code example produces the following output:
//
// The result of executing the expression tree:
// Hello World!

// The expressions from the block expression:
// Write("Hello ")
// WriteLine("World!")
// 42

// The return value of the block expression:
// 42

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

' The block expression enables you to execute several expressions sequentually.
' When the block expression is executed,
' it returns the value of the last expression in the sequence.
Dim blockExpr As BlockExpression = Expression.Block(
    Expression.Call(
        Nothing,
        GetType(Console).GetMethod("Write", New Type() {GetType(String)}),
        Expression.Constant("Hello ")
       ),
    Expression.Call(
        Nothing,
        GetType(Console).GetMethod("WriteLine", New Type() {GetType(String)}),
        Expression.Constant("World!")
        ),
    Expression.Constant(42)
)

Console.WriteLine("The result of executing the expression tree:")
' The following statement first creates an expression tree,
' then compiles it, and then executes it.           
Dim result = Expression.Lambda(Of Func(Of Integer))(blockExpr).Compile()()

' Print the expressions from the block expression.
Console.WriteLine("The expressions from the block expression:")
For Each expr In blockExpr.Expressions
    Console.WriteLine(expr.ToString())
Next

' Print the result of the tree execution.
Console.WriteLine("The return value of the block expression:")
Console.WriteLine(result)

' This code example produces the following output:
'
' The result of executing the expression tree:
' Hello World!

' The expressions from the block expression:
' Write("Hello ")
' WriteLine("World!")
' 42

' The return value of the block expression:
' 42

Konstruktorer

Name Description
Expression()

Konstruerar en ny instans av Expression.
Expression(ExpressionType, Type)
Föråldrad.

Initierar en ny instans av Expression klassen.

Egenskaper

Name Description
CanReduce

Anger att noden kan reduceras till en enklare nod. Om detta returnerar true kan Reduce() anropas för att skapa det reducerade formuläret.
NodeType

Hämtar nodtypen för den här Expression.
Type

Hämtar den statiska typen av uttryck som detta Expression representerar.

Metoder

Name Description
Accept(ExpressionVisitor)

Skickar till den specifika besöksmetoden för den här nodtypen. Anropar MethodCallExpressionVisitMethodCall(MethodCallExpression)till exempel .
Add(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmisk additionsåtgärd som inte har spillkontroll. Implementeringsmetoden kan anges.
Add(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmisk additionsåtgärd som inte har spillkontroll.
AddAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en tilläggstilldelningsåtgärd som inte har spillkontroll.
AddAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en tilläggstilldelningsåtgärd som inte har spillkontroll.
AddAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en tilläggstilldelningsåtgärd som inte har spillkontroll.
AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en tilläggstilldelningsåtgärd som har spillkontroll.
AddAssignChecked(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en tilläggstilldelningsåtgärd som har spillkontroll.
AddAssignChecked(Expression, Expression)

Skapar en BinaryExpression som representerar en tilläggstilldelningsåtgärd som har spillkontroll.
AddChecked(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmetisk additionsåtgärd som har spillkontroll. Implementeringsmetoden kan anges.
AddChecked(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmetisk additionsåtgärd som har spillkontroll.
And(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis AND åtgärd. Implementeringsmetoden kan anges.
And(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis AND åtgärd.
AndAlso(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en villkorsstyrd AND åtgärd som utvärderar den andra operanden endast om den första operanden matchas till true. Implementeringsmetoden kan anges.
AndAlso(Expression, Expression)

Skapar en BinaryExpression som representerar en villkorsstyrd AND åtgärd som utvärderar den andra operanden endast om den första operanden utvärderas till true.
AndAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en bitvis OCH tilldelningsåtgärd.
AndAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis OCH tilldelningsåtgärd.
AndAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis OCH tilldelningsåtgärd.
ArrayAccess(Expression, Expression[])

Skapar en IndexExpression för att komma åt en matris.
ArrayAccess(Expression, IEnumerable<Expression>)

Skapar en IndexExpression för att komma åt en flerdimensionell matris.
ArrayIndex(Expression, Expression)

Skapar en BinaryExpression som representerar att tillämpa en matrisindexoperator på en matris med rangordning ett.
ArrayIndex(Expression, Expression[])

Skapar en MethodCallExpression som representerar att tillämpa en matrisindexoperator på en flerdimensionell matris.
ArrayIndex(Expression, IEnumerable<Expression>)

Skapar en MethodCallExpression som representerar att tillämpa en matrisindexoperator på en matris med rangordning mer än en.
ArrayLength(Expression)

Skapar ett UnaryExpression som representerar ett uttryck för att hämta längden på en endimensionell matris.
Assign(Expression, Expression)

Skapar en BinaryExpression som representerar en tilldelningsåtgärd.
Bind(MemberInfo, Expression)

Skapar en MemberAssignment som representerar initieringen av ett fält eller en egenskap.
Bind(MethodInfo, Expression)

Skapar en MemberAssignment som representerar initieringen av en medlem med hjälp av en egenskapsåtkomstmetod.
Block(Expression, Expression, Expression, Expression, Expression)

Skapar ett BlockExpression som innehåller fem uttryck och som inte har några variabler.
Block(Expression, Expression, Expression, Expression)

Skapar ett BlockExpression som innehåller fyra uttryck och inte har några variabler.
Block(Expression, Expression, Expression)

Skapar ett BlockExpression som innehåller tre uttryck och inte har några variabler.
Block(Expression, Expression)

Skapar ett BlockExpression som innehåller två uttryck och inte har några variabler.
Block(Expression[])

Skapar ett BlockExpression som innehåller de givna uttrycken och inte har några variabler.
Block(IEnumerable<Expression>)

Skapar ett BlockExpression som innehåller de givna uttrycken och inte har några variabler.
Block(IEnumerable<ParameterExpression>, Expression[])

Skapar en BlockExpression som innehåller de angivna variablerna och uttrycken.
Block(IEnumerable<ParameterExpression>, IEnumerable<Expression>)

Skapar en BlockExpression som innehåller de angivna variablerna och uttrycken.
Block(Type, Expression[])

Skapar en BlockExpression som innehåller de givna uttrycken, har inga variabler och har en specifik resultattyp.
Block(Type, IEnumerable<Expression>)

Skapar en BlockExpression som innehåller de givna uttrycken, har inga variabler och har en specifik resultattyp.
Block(Type, IEnumerable<ParameterExpression>, Expression[])

Skapar en BlockExpression som innehåller de angivna variablerna och uttrycken.
Block(Type, IEnumerable<ParameterExpression>, IEnumerable<Expression>)

Skapar en BlockExpression som innehåller de angivna variablerna och uttrycken.
Break(LabelTarget, Expression, Type)

Skapar en GotoExpression som representerar en brytsats med den angivna typen. Det värde som skickas till etiketten vid hoppning kan anges.
Break(LabelTarget, Expression)

Skapar en GotoExpression som representerar en brytsats. Det värde som skickas till etiketten vid hoppning kan anges.
Break(LabelTarget, Type)

Skapar en GotoExpression som representerar en brytsats med den angivna typen.
Break(LabelTarget)

Skapar en GotoExpression som representerar en brytsats.
Call(Expression, MethodInfo, Expression, Expression, Expression)

Skapar ett MethodCallExpression som representerar ett anrop till en metod som tar tre argument.
Call(Expression, MethodInfo, Expression, Expression)

Skapar en MethodCallExpression som representerar ett anrop till en metod som tar två argument.
Call(Expression, MethodInfo, Expression[])

Skapar ett MethodCallExpression som representerar ett anrop till en metod som tar argument.
Call(Expression, MethodInfo, IEnumerable<Expression>)

Skapar ett MethodCallExpression som representerar ett anrop till en metod som tar argument.
Call(Expression, MethodInfo)

Skapar ett MethodCallExpression som representerar ett anrop till en metod som inte tar några argument.
Call(Expression, String, Type[], Expression[])

Skapar en MethodCallExpression som representerar ett anrop till en metod genom att anropa lämplig fabriksmetod.
Call(MethodInfo, Expression, Expression, Expression, Expression, Expression)

Skapar ett MethodCallExpression som representerar ett anrop till en statisk metod som tar fem argument.
Call(MethodInfo, Expression, Expression, Expression, Expression)

Skapar en MethodCallExpression som representerar ett anrop till en statisk metod som tar fyra argument.
Call(MethodInfo, Expression, Expression, Expression)

Skapar ett MethodCallExpression som representerar ett anrop till en statisk metod som tar tre argument.
Call(MethodInfo, Expression, Expression)

Skapar en MethodCallExpression som representerar ett anrop till en statisk metod som tar två argument.
Call(MethodInfo, Expression)

Skapar en MethodCallExpression som representerar ett anrop till en metod static (Shared i Visual Basic) som tar ett argument.
Call(MethodInfo, Expression[])

Skapar en MethodCallExpression som representerar ett anrop till en metod static (Shared i Visual Basic) som har argument.
Call(MethodInfo, IEnumerable<Expression>)

Skapar en MethodCallExpression som representerar ett anrop till en statisk metod (delad i Visual Basic).
Call(Type, String, Type[], Expression[])

Skapar en MethodCallExpression som representerar ett anrop till metoden static (Shared i Visual Basic) genom att anropa lämplig fabriksmetod.
Catch(ParameterExpression, Expression, Expression)

Skapar en CatchBlock som representerar en catch-instruktion med ett Exception filter och en referens till det fångade Exception objektet.
Catch(ParameterExpression, Expression)

Skapar en CatchBlock som representerar en catch-instruktion med en referens till det fångade Exception objektet för användning i hanterartexten.
Catch(Type, Expression, Expression)

Skapar en CatchBlock som representerar en catch-instruktion med ett Exception filter men ingen referens till det fångade Exception objektet.
Catch(Type, Expression)

Skapar en CatchBlock som representerar en catch-instruktion.
ClearDebugInfo(SymbolDocumentInfo)

Skapar en DebugInfoExpression för att rensa en sekvenspunkt.
Coalesce(Expression, Expression, LambdaExpression)

Skapar en BinaryExpression som representerar en sammankopplingsåtgärd, givet en konverteringsfunktion.
Coalesce(Expression, Expression)

Skapar en BinaryExpression som representerar en sammankopplingsåtgärd.
Condition(Expression, Expression, Expression, Type)

Skapar en ConditionalExpression som representerar en villkorsstyrd instruktion.
Condition(Expression, Expression, Expression)

Skapar en ConditionalExpression som representerar en villkorsstyrd instruktion.
Constant(Object, Type)

Skapar en ConstantExpression som har Value egenskaperna och Type inställda på de angivna värdena.
Constant(Object)

Skapar en ConstantExpression som har egenskapen Value inställd på det angivna värdet.
Continue(LabelTarget, Type)

Skapar en GotoExpression som representerar en fortsätt-instruktion med den angivna typen.
Continue(LabelTarget)

Skapar en GotoExpression som representerar en continue-instruktion.
Convert(Expression, Type, MethodInfo)

Skapar en UnaryExpression som representerar en konverteringsåtgärd som implementeringsmetoden har angetts för.
Convert(Expression, Type)

Skapar en UnaryExpression som representerar en typkonverteringsåtgärd.
ConvertChecked(Expression, Type, MethodInfo)

Skapar en UnaryExpression som representerar en konverteringsåtgärd som utlöser ett undantag om måltypen spills över och för vilken implementeringsmetoden har angetts.
ConvertChecked(Expression, Type)

Skapar en UnaryExpression som representerar en konverteringsåtgärd som utlöser ett undantag om måltypen är översvämmad.
DebugInfo(SymbolDocumentInfo, Int32, Int32, Int32, Int32)

Skapar en DebugInfoExpression med det angivna intervallet.
Decrement(Expression, MethodInfo)

Skapar en UnaryExpression som representerar dementeringen av uttrycket med 1.
Decrement(Expression)

Skapar en UnaryExpression som representerar dementeringen av uttrycket med 1.
Default(Type)

Skapar en DefaultExpression som har egenskapen Type inställd på den angivna typen.
Divide(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmisk divisionsåtgärd. Implementeringsmetoden kan anges.
Divide(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmisk divisionsåtgärd.
DivideAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en divisionstilldelningsåtgärd som inte har spillkontroll.
DivideAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en divisionstilldelningsåtgärd som inte har spillkontroll.
DivideAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en divisionstilldelningsåtgärd som inte har spillkontroll.
Dynamic(CallSiteBinder, Type, Expression, Expression, Expression, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression, Expression, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
Dynamic(CallSiteBinder, Type, Expression[])

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
Dynamic(CallSiteBinder, Type, IEnumerable<Expression>)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
ElementInit(MethodInfo, Expression[])

Skapar en ElementInit, givet en matris med värden som det andra argumentet.
ElementInit(MethodInfo, IEnumerable<Expression>)

Skapar ett ElementInit, givet IEnumerable<T> som det andra argumentet.
Empty()

Skapar ett tomt uttryck som har Void typen .
Equal(Expression, Expression, Boolean, MethodInfo)

Skapar en BinaryExpression som representerar en likhetsjämförelse. Implementeringsmetoden kan anges.
Equal(Expression, Expression)

Skapar en BinaryExpression som representerar en likhetsjämförelse.
Equals(Object)

Avgör om det angivna objektet är lika med det aktuella objektet.

(Ärvd från Object)
ExclusiveOr(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis XOR åtgärd med hjälp av op_ExclusiveOr för användardefinierade typer. Implementeringsmetoden kan anges.
ExclusiveOr(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis XOR åtgärd med hjälp av op_ExclusiveOr för användardefinierade typer.
ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en bitvis XOR-tilldelningsåtgärd med hjälp av op_ExclusiveOr för användardefinierade typer.
ExclusiveOrAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis XOR-tilldelningsåtgärd med hjälp av op_ExclusiveOr för användardefinierade typer.
ExclusiveOrAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis XOR-tilldelningsåtgärd med hjälp av op_ExclusiveOr för användardefinierade typer.
Field(Expression, FieldInfo)

Skapar en MemberExpression som representerar åtkomst till ett fält.
Field(Expression, String)

Skapar en MemberExpression som representerar åtkomst till ett fält med namnet på fältet.
Field(Expression, Type, String)

Skapar en MemberExpression som representerar åtkomst till ett fält.
GetActionType(Type[])

Skapar ett Type objekt som representerar en allmän Action ombudstyp som har specifika typargument.
GetDelegateType(Type[])

Hämtar ett Type objekt som representerar en allmän Func<TResult> eller Action delegerad typ som har specifika typargument.
GetFuncType(Type[])

Skapar ett Type objekt som representerar en allmän Func<TResult> ombudstyp som har specifika typargument. Det sista typargumentet anger returtypen för det skapade ombudet.
GetHashCode()

Fungerar som standard-hash-funktion.

(Ärvd från Object)
GetType()

Hämtar den aktuella instansen Type .

(Ärvd från Object)
Goto(LabelTarget, Expression, Type)

Skapar en GotoExpression som representerar en "gå till"-instruktion med den angivna typen. Det värde som skickas till etiketten vid hoppning kan anges.
Goto(LabelTarget, Expression)

Skapar en GotoExpression som representerar en "gå till"-instruktion. Det värde som skickas till etiketten vid hoppning kan anges.
Goto(LabelTarget, Type)

Skapar en GotoExpression som representerar en "gå till"-instruktion med den angivna typen.
Goto(LabelTarget)

Skapar en GotoExpression som representerar en "gå till"-instruktion.
GreaterThan(Expression, Expression, Boolean, MethodInfo)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är "större än". Implementeringsmetoden kan anges.
GreaterThan(Expression, Expression)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är "större än".
GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är större än eller lika med.
GreaterThanOrEqual(Expression, Expression)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är större än eller lika med.
IfThen(Expression, Expression)

Skapar en ConditionalExpression som representerar ett villkorsblock med en if instruktion.
IfThenElse(Expression, Expression, Expression)

Skapar en ConditionalExpression som representerar ett villkorsblock med if och else -instruktioner.
Increment(Expression, MethodInfo)

Skapar en UnaryExpression som representerar inkrementeringen av uttrycket med 1.
Increment(Expression)

Skapar en UnaryExpression som representerar inkrementeringen av uttrycksvärdet med 1.
Invoke(Expression, Expression[])

Skapar ett InvocationExpression som tillämpar ett ombuds- eller lambda-uttryck på en lista över argumentuttryck.
Invoke(Expression, IEnumerable<Expression>)

Skapar ett InvocationExpression som tillämpar ett ombuds- eller lambda-uttryck på en lista över argumentuttryck.
IsFalse(Expression, MethodInfo)

Returnerar om uttrycket utvärderas till falskt.
IsFalse(Expression)

Returnerar om uttrycket utvärderas till falskt.
IsTrue(Expression, MethodInfo)

Returnerar om uttrycket utvärderas till sant.
IsTrue(Expression)

Returnerar om uttrycket utvärderas till sant.
Label()

Skapar en LabelTarget som representerar en etikett med tomrumstyp och inget namn.
Label(LabelTarget, Expression)

Skapar en LabelExpression som representerar en etikett med det angivna standardvärdet.
Label(LabelTarget)

Skapar en LabelExpression som representerar en etikett utan ett standardvärde.
Label(String)

Skapar en LabelTarget som representerar en etikett med tomrumstyp och det angivna namnet.
Label(Type, String)

Skapar en LabelTarget som representerar en etikett med den angivna typen och namnet.
Label(Type)

Skapar en LabelTarget som representerar en etikett med den angivna typen.
Lambda(Expression, Boolean, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression genom att först konstruera en ombudstyp från uttryckstexten, en parameter som anger om optimering av tail-anrop ska tillämpas och en uppräkningsbar samling parameteruttryck. Den kan användas när ombudstypen inte är känd vid kompileringstillfället.
Lambda(Expression, Boolean, ParameterExpression[])

Skapar en LambdaExpression genom att först konstruera en ombudstyp från uttryckstexten, en parameter som anger om tail call-optimering ska tillämpas och en matris med parameteruttryck. Den kan användas när ombudstypen inte är känd vid kompileringstillfället.
Lambda(Expression, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression genom att först konstruera en ombudstyp från uttryckstexten och en uppräkningsbar samling parameteruttryck. Den kan användas när ombudstypen inte är känd vid kompileringstillfället.
Lambda(Expression, ParameterExpression[])

Skapar en LambdaExpression genom att först konstruera en ombudstyp från uttryckstexten och en matris med parameteruttryck. Den kan användas när ombudstypen inte är känd vid kompileringstillfället.
Lambda(Expression, String, Boolean, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression genom att först konstruera en ombudstyp från uttryckstexten, namnet på lambda, en parameter som anger om optimering av tail-anrop ska tillämpas och en uppräkningsbar samling parameteruttryck. Den kan användas när ombudstypen inte är känd vid kompileringstillfället.
Lambda(Expression, String, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression genom att först konstruera en ombudstyp från uttryckstexten, namnet på lambda och en uppräkningsbar samling parameteruttryck. Den kan användas när ombudstypen inte är känd vid kompileringstillfället.
Lambda(Type, Expression, Boolean, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression där ombudstypen är känd vid kompileringstillfället, med en parameter som anger om optimering av tail call kommer att tillämpas och en uppräkningsbar samling parameteruttryck.
Lambda(Type, Expression, Boolean, ParameterExpression[])

Skapar en LambdaExpression där ombudstypen är känd vid kompileringstillfället, med en parameter som anger om optimering av tail call kommer att tillämpas och en matris med parameteruttryck.
Lambda(Type, Expression, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression där ombudstypen är känd vid kompileringstillfället, med en uppräkningsbar samling parameteruttryck.
Lambda(Type, Expression, ParameterExpression[])

Skapar en LambdaExpression där ombudstypen är känd vid kompileringstillfället, med en matris med parameteruttryck.
Lambda(Type, Expression, String, Boolean, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression där ombudstypen är känd vid kompileringstillfället, med namnet på lambda, en parameter som anger om optimering av tail call kommer att tillämpas och en uppräkningsbar samling parameteruttryck.
Lambda(Type, Expression, String, IEnumerable<ParameterExpression>)

Skapar en LambdaExpression där delegattypen är känd vid kompileringstillfället, med namnet på lambda och en uppräkningsbar samling parameteruttryck.
Lambda<TDelegate>(Expression, Boolean, IEnumerable<ParameterExpression>)

Skapar en Expression<TDelegate> där ombudstypen är känd vid kompileringstillfället, med en parameter som anger om optimering av tail call kommer att tillämpas och en uppräkningsbar samling parameteruttryck.
Lambda<TDelegate>(Expression, Boolean, ParameterExpression[])

Skapar en Expression<TDelegate> där delegattypen är känd vid kompileringstillfället, med en parameter som anger om optimering av tail call kommer att tillämpas och en matris med parameteruttryck.
Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>)

Skapar en Expression<TDelegate> där ombudstypen är känd vid kompileringstillfället, med en uppräkningsbar samling parameteruttryck.
Lambda<TDelegate>(Expression, ParameterExpression[])

Skapar en Expression<TDelegate> där ombudstypen är känd vid kompileringstillfället, med en matris med parameteruttryck.
Lambda<TDelegate>(Expression, String, Boolean, IEnumerable<ParameterExpression>)

Skapar en Expression<TDelegate> där ombudstypen är känd vid kompileringstillfället, med namnet på lambda, en parameter som anger om optimering av tail-anrop kommer att tillämpas och en uppräkningsbar samling parameteruttryck.
Lambda<TDelegate>(Expression, String, IEnumerable<ParameterExpression>)

Skapar en Expression<TDelegate> där delegattypen är känd vid kompileringstid, med namnet på lambda och en uppräkningsbar samling parameteruttryck.
LeftShift(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis vänsterskiftsåtgärd.
LeftShift(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis vänsterskiftsåtgärd.
LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en bitvis vänsterskiftstilldelningsåtgärd.
LeftShiftAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis vänsterskiftstilldelningsåtgärd.
LeftShiftAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis vänsterskiftstilldelningsåtgärd.
LessThan(Expression, Expression, Boolean, MethodInfo)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är mindre än.
LessThan(Expression, Expression)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är mindre än.
LessThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är mindre än eller lika med.
LessThanOrEqual(Expression, Expression)

Skapar en BinaryExpression som representerar en numerisk jämförelse som är mindre än eller lika med.
ListBind(MemberInfo, ElementInit[])

Skapar en MemberListBinding plats där medlemmen är ett fält eller en egenskap.
ListBind(MemberInfo, IEnumerable<ElementInit>)

Skapar en MemberListBinding plats där medlemmen är ett fält eller en egenskap.
ListBind(MethodInfo, ElementInit[])

Skapar ett MemberListBinding objekt baserat på en angiven egenskapsåtkomstmetod.
ListBind(MethodInfo, IEnumerable<ElementInit>)

Skapar en MemberListBinding baserad på en angiven egenskapsåtkomstmetod.
ListInit(NewExpression, ElementInit[])

Skapar en ListInitExpression som använder angivna ElementInit objekt för att initiera en samling.
ListInit(NewExpression, Expression[])

Skapar en ListInitExpression som använder en metod med namnet "Lägg till" för att lägga till element i en samling.
ListInit(NewExpression, IEnumerable<ElementInit>)

Skapar en ListInitExpression som använder angivna ElementInit objekt för att initiera en samling.
ListInit(NewExpression, IEnumerable<Expression>)

Skapar en ListInitExpression som använder en metod med namnet "Lägg till" för att lägga till element i en samling.
ListInit(NewExpression, MethodInfo, Expression[])

Skapar en ListInitExpression som använder en angiven metod för att lägga till element i en samling.
ListInit(NewExpression, MethodInfo, IEnumerable<Expression>)

Skapar en ListInitExpression som använder en angiven metod för att lägga till element i en samling.
Loop(Expression, LabelTarget, LabelTarget)

Skapar en LoopExpression med den angivna brödtexten.
Loop(Expression, LabelTarget)

Skapar en LoopExpression med den angivna brödtexten och brytmålet.
Loop(Expression)

Skapar en LoopExpression med den angivna brödtexten.
MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo, LambdaExpression)

Skapar en BinaryExpression, givet vänster operand, höger operand, implementeringsmetod och typkonverteringsfunktion genom att anropa lämplig fabriksmetod.
MakeBinary(ExpressionType, Expression, Expression, Boolean, MethodInfo)

Skapar en BinaryExpression, givet vänster operand, höger operand och implementeringsmetod genom att anropa lämplig fabriksmetod.
MakeBinary(ExpressionType, Expression, Expression)

Skapar en BinaryExpression, givet vänster och höger operander, genom att anropa en lämplig fabriksmetod.
MakeCatchBlock(Type, ParameterExpression, Expression, Expression)

Skapar en CatchBlock som representerar en catch-instruktion med de angivna elementen.
MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av de angivna CallSiteBinder och fyra argumenten.
MakeDynamic(Type, CallSiteBinder, Expression, Expression, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av de angivna CallSiteBinder och tre argumenten.
MakeDynamic(Type, CallSiteBinder, Expression, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av de angivna CallSiteBinder och två argumenten.
MakeDynamic(Type, CallSiteBinder, Expression)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av det angivna CallSiteBinder argumentet och ett argument.
MakeDynamic(Type, CallSiteBinder, Expression[])

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
MakeDynamic(Type, CallSiteBinder, IEnumerable<Expression>)

Skapar en DynamicExpression som representerar en dynamisk åtgärd som är bunden av den angivna CallSiteBinder.
MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type)

Skapar ett GotoExpression som representerar ett hopp av angivet GotoExpressionKind. Det värde som skickas till etiketten vid hoppning kan också anges.
MakeIndex(Expression, PropertyInfo, IEnumerable<Expression>)

Skapar en IndexExpression som representerar åtkomst till en indexerad egenskap i ett objekt.
MakeMemberAccess(Expression, MemberInfo)

Skapar en MemberExpression som representerar åtkomst till antingen ett fält eller en egenskap.
MakeTry(Type, Expression, Expression, Expression, IEnumerable<CatchBlock>)

Skapar ett TryExpression försöksblock som representerar ett försöksblock med de angivna elementen.
MakeUnary(ExpressionType, Expression, Type, MethodInfo)

Skapar en UnaryExpression, givet en operand- och implementeringsmetod genom att anropa lämplig fabriksmetod.
MakeUnary(ExpressionType, Expression, Type)

Skapar en UnaryExpression, angiven operand, genom att anropa lämplig fabriksmetod.
MemberBind(MemberInfo, IEnumerable<MemberBinding>)

Skapar en MemberMemberBinding som representerar den rekursiva initieringen av medlemmar i ett fält eller en egenskap.
MemberBind(MemberInfo, MemberBinding[])

Skapar en MemberMemberBinding som representerar den rekursiva initieringen av medlemmar i ett fält eller en egenskap.
MemberBind(MethodInfo, IEnumerable<MemberBinding>)

Skapar en MemberMemberBinding som representerar den rekursiva initieringen av medlemmar i en medlem som nås med hjälp av en egenskapsåtkomstmetod.
MemberBind(MethodInfo, MemberBinding[])

Skapar en MemberMemberBinding som representerar den rekursiva initieringen av medlemmar i en medlem som nås med hjälp av en egenskapsåtkomstmetod.
MemberInit(NewExpression, IEnumerable<MemberBinding>)

Representerar ett uttryck som skapar ett nytt objekt och initierar en egenskap för objektet.
MemberInit(NewExpression, MemberBinding[])

Skapar en MemberInitExpression.
MemberwiseClone()

Skapar en ytlig kopia av den aktuella Object.

(Ärvd från Object)
Modulo(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmisk reståtgärd.
Modulo(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmisk reståtgärd.
ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en resttilldelningsåtgärd.
ModuloAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en resttilldelningsåtgärd.
ModuloAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en resttilldelningsåtgärd.
Multiply(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmtisk multiplikationsåtgärd som inte har spillkontroll.
Multiply(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmtisk multiplikationsåtgärd som inte har spillkontroll.
MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en multiplikationstilldelningsåtgärd som inte har spillkontroll.
MultiplyAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en multiplikationstilldelningsåtgärd som inte har spillkontroll.
MultiplyAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en multiplikationstilldelningsåtgärd som inte har spillkontroll.
MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en multiplikationstilldelningsåtgärd som har spillkontroll.
MultiplyAssignChecked(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en multiplikationstilldelningsåtgärd som har spillkontroll.
MultiplyAssignChecked(Expression, Expression)

Skapar en BinaryExpression som representerar en multiplikationstilldelningsåtgärd som har spillkontroll.
MultiplyChecked(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmtisk multiplikationsåtgärd som har spillkontroll.
MultiplyChecked(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmtisk multiplikationsåtgärd som har spillkontroll.
Negate(Expression, MethodInfo)

Skapar en UnaryExpression som representerar en aritmisk negation.
Negate(Expression)

Skapar en UnaryExpression som representerar en aritmisk negation.
NegateChecked(Expression, MethodInfo)

Skapar en UnaryExpression som representerar en aritmisk negation som har spillkontroll. Implementeringsmetoden kan anges.
NegateChecked(Expression)

Skapar en UnaryExpression som representerar en aritmisk negation som har spillkontroll.
New(ConstructorInfo, Expression[])

Skapar en NewExpression som representerar att anropa den angivna konstruktorn med de angivna argumenten.
New(ConstructorInfo, IEnumerable<Expression>, IEnumerable<MemberInfo>)

Skapar en NewExpression som representerar att anropa den angivna konstruktorn med de angivna argumenten. De medlemmar som har åtkomst till konstruktorns initierade fält anges.
New(ConstructorInfo, IEnumerable<Expression>, MemberInfo[])

Skapar en NewExpression som representerar att anropa den angivna konstruktorn med de angivna argumenten. De medlemmar som har åtkomst till konstruktorns initierade fält anges som en matris.
New(ConstructorInfo, IEnumerable<Expression>)

Skapar en NewExpression som representerar att anropa den angivna konstruktorn med de angivna argumenten.
New(ConstructorInfo)

Skapar en NewExpression som representerar att anropa den angivna konstruktorn som inte tar några argument.
New(Type)

Skapar en NewExpression som representerar att anropa den parameterlösa konstruktorn av den angivna typen.
NewArrayBounds(Type, Expression[])

Skapar en NewArrayExpression som representerar skapandet av en matris som har en angiven rangordning.
NewArrayBounds(Type, IEnumerable<Expression>)

Skapar en NewArrayExpression som representerar skapandet av en matris som har en angiven rangordning.
NewArrayInit(Type, Expression[])

Skapar en NewArrayExpression som representerar skapandet av en endimensionell matris och initierar den från en lista med element.
NewArrayInit(Type, IEnumerable<Expression>)

Skapar en NewArrayExpression som representerar skapandet av en endimensionell matris och initierar den från en lista med element.
Not(Expression, MethodInfo)

Skapar en UnaryExpression som representerar en bitvis komplementåtgärd. Implementeringsmetoden kan anges.
Not(Expression)

Skapar en UnaryExpression som representerar en bitvis komplementåtgärd.
NotEqual(Expression, Expression, Boolean, MethodInfo)

Skapar en BinaryExpression som representerar en jämförelse av ojämlikhet.
NotEqual(Expression, Expression)

Skapar en BinaryExpression som representerar en jämförelse av ojämlikhet.
OnesComplement(Expression, MethodInfo)

Returnerar uttrycket som representerar ettornas komplement.
OnesComplement(Expression)

Returnerar uttrycket som representerar ettornas komplement.
Or(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis OR åtgärd.
Or(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis OR åtgärd.
OrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en bitvis ELLER tilldelningsåtgärd.
OrAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis ELLER tilldelningsåtgärd.
OrAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis ELLER tilldelningsåtgärd.
OrElse(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en villkorsstyrd OR åtgärd som utvärderar den andra operanden endast om den första operanden utvärderas till false.
OrElse(Expression, Expression)

Skapar en BinaryExpression som representerar en villkorsstyrd OR åtgärd som utvärderar den andra operanden endast om den första operanden utvärderas till false.
Parameter(Type, String)

Skapar en ParameterExpression nod som kan användas för att identifiera en parameter eller en variabel i ett uttrycksträd.
Parameter(Type)

Skapar en ParameterExpression nod som kan användas för att identifiera en parameter eller en variabel i ett uttrycksträd.
PostDecrementAssign(Expression, MethodInfo)

Skapar en UnaryExpression som representerar tilldelningen av uttrycket följt av en efterföljande minskning med 1 av det ursprungliga uttrycket.
PostDecrementAssign(Expression)

Skapar en UnaryExpression som representerar tilldelningen av uttrycket följt av en efterföljande minskning med 1 av det ursprungliga uttrycket.
PostIncrementAssign(Expression, MethodInfo)

Skapar en UnaryExpression som representerar tilldelningen av uttrycket följt av en efterföljande ökning med 1 av det ursprungliga uttrycket.
PostIncrementAssign(Expression)

Skapar en UnaryExpression som representerar tilldelningen av uttrycket följt av en efterföljande ökning med 1 av det ursprungliga uttrycket.
Power(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar att höja ett tal till en makt.
Power(Expression, Expression)

Skapar en BinaryExpression som representerar att höja ett tal till en makt.
PowerAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar att höja ett uttryck till en kraft och tilldela resultatet tillbaka till uttrycket.
PowerAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar att höja ett uttryck till en kraft och tilldela resultatet tillbaka till uttrycket.
PowerAssign(Expression, Expression)

Skapar en BinaryExpression som representerar att höja ett uttryck till en kraft och tilldela resultatet tillbaka till uttrycket.
PreDecrementAssign(Expression, MethodInfo)

Skapar en UnaryExpression som minskar uttrycket med 1 och tilldelar resultatet tillbaka till uttrycket.
PreDecrementAssign(Expression)

Skapar en UnaryExpression som minskar uttrycket med 1 och tilldelar resultatet tillbaka till uttrycket.
PreIncrementAssign(Expression, MethodInfo)

Skapar en UnaryExpression som ökar uttrycket med 1 och tilldelar resultatet tillbaka till uttrycket.
PreIncrementAssign(Expression)

Skapar en UnaryExpression som ökar uttrycket med 1 och tilldelar resultatet tillbaka till uttrycket.
Property(Expression, MethodInfo)

Skapar en MemberExpression som representerar åtkomst till en egenskap med hjälp av en egenskapsåtkomstmetod.
Property(Expression, PropertyInfo, Expression[])

Skapar en IndexExpression som representerar åtkomsten till en indexerad egenskap.
Property(Expression, PropertyInfo, IEnumerable<Expression>)

Skapar en IndexExpression som representerar åtkomsten till en indexerad egenskap.
Property(Expression, PropertyInfo)

Skapar en MemberExpression som representerar åtkomst till en egenskap.
Property(Expression, String, Expression[])

Skapar en IndexExpression som representerar åtkomsten till en indexerad egenskap.
Property(Expression, String)

Skapar en MemberExpression som representerar åtkomst till en egenskap.
Property(Expression, Type, String)

Skapar en MemberExpression åtkomst till en egenskap.
PropertyOrField(Expression, String)

Skapar en MemberExpression som representerar åtkomst till en egenskap eller ett fält.
Quote(Expression)

Skapar ett UnaryExpression som representerar ett uttryck som har ett konstant värde av typen Expression.
Reduce()

Reducerar den här noden till ett enklare uttryck. Om CanReduce returnerar true bör detta returnera ett giltigt uttryck. Den här metoden kan returnera en annan nod som måste minskas.
ReduceAndCheck()

Reducerar den här noden till ett enklare uttryck. Om CanReduce returnerar true bör detta returnera ett giltigt uttryck. Den här metoden kan returnera en annan nod som måste minskas.
ReduceExtensions()

Minskar uttrycket till en känd nodtyp (som inte är en tilläggsnod) eller returnerar bara uttrycket om det redan är en känd typ.
ReferenceEqual(Expression, Expression)

Skapar en BinaryExpression som representerar en jämförelse av referensjämlikhet.
ReferenceNotEqual(Expression, Expression)

Skapar en BinaryExpression som representerar en referensjämlikhetsjämförelse.
Rethrow()

Skapar en UnaryExpression som representerar en återväxt av ett undantag.
Rethrow(Type)

Skapar en UnaryExpression som representerar en återväxt av ett undantag med en viss typ.
Return(LabelTarget, Expression, Type)

Skapar en GotoExpression som representerar en retursats med den angivna typen. Det värde som skickas till etiketten vid hoppning kan anges.
Return(LabelTarget, Expression)

Skapar en GotoExpression som representerar en retursats. Det värde som skickas till etiketten vid hoppning kan anges.
Return(LabelTarget, Type)

Skapar en GotoExpression som representerar en retursats med den angivna typen.
Return(LabelTarget)

Skapar en GotoExpression som representerar en retursats.
RightShift(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis rätt skift-åtgärd.
RightShift(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis rätt skift-åtgärd.
RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en bitvis högerskiftstilldelningsåtgärd.
RightShiftAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en bitvis högerskiftstilldelningsåtgärd.
RightShiftAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en bitvis högerskiftstilldelningsåtgärd.
RuntimeVariables(IEnumerable<ParameterExpression>)

Skapar en instans av RuntimeVariablesExpression.
RuntimeVariables(ParameterExpression[])

Skapar en instans av RuntimeVariablesExpression.
Subtract(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmisk subtraktionsåtgärd som inte har spillkontroll.
Subtract(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmisk subtraktionsåtgärd som inte har spillkontroll.
SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en subtraktionstilldelningsåtgärd som inte har spillkontroll.
SubtractAssign(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en subtraktionstilldelningsåtgärd som inte har spillkontroll.
SubtractAssign(Expression, Expression)

Skapar en BinaryExpression som representerar en subtraktionstilldelningsåtgärd som inte har spillkontroll.
SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Skapar en BinaryExpression som representerar en subtraktionstilldelningsåtgärd som har spillkontroll.
SubtractAssignChecked(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en subtraktionstilldelningsåtgärd som har spillkontroll.
SubtractAssignChecked(Expression, Expression)

Skapar en BinaryExpression som representerar en subtraktionstilldelningsåtgärd som har spillkontroll.
SubtractChecked(Expression, Expression, MethodInfo)

Skapar en BinaryExpression som representerar en aritmisk subtraktionsåtgärd som har spillkontroll.
SubtractChecked(Expression, Expression)

Skapar en BinaryExpression som representerar en aritmisk subtraktionsåtgärd som har spillkontroll.
Switch(Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Skapar en SwitchExpression som representerar en switch -instruktion som har ett standardfall.
Switch(Expression, Expression, MethodInfo, SwitchCase[])

Skapar en SwitchExpression som representerar en switch -instruktion som har ett standardfall.
Switch(Expression, Expression, SwitchCase[])

Skapar en SwitchExpression som representerar en switch -instruktion som har ett standardfall.
Switch(Expression, SwitchCase[])

Skapar en SwitchExpression som representerar en switch -instruktion utan standardfall.
Switch(Type, Expression, Expression, MethodInfo, IEnumerable<SwitchCase>)

Skapar en SwitchExpression som representerar en switch -instruktion som har ett standardfall.
Switch(Type, Expression, Expression, MethodInfo, SwitchCase[])

Skapar en SwitchExpression som representerar en switch -instruktion som har ett standardfall.
SwitchCase(Expression, Expression[])

Skapar en SwitchCase för användning i en SwitchExpression.
SwitchCase(Expression, IEnumerable<Expression>)

Skapar ett SwitchCase objekt som ska användas i ett SwitchExpression objekt.
SymbolDocument(String, Guid, Guid, Guid)

Skapar en instans av SymbolDocumentInfo.
SymbolDocument(String, Guid, Guid)

Skapar en instans av SymbolDocumentInfo.
SymbolDocument(String, Guid)

Skapar en instans av SymbolDocumentInfo.
SymbolDocument(String)

Skapar en instans av SymbolDocumentInfo.
Throw(Expression, Type)

Skapar en UnaryExpression som representerar en utkastning av ett undantag med en viss typ.
Throw(Expression)

Skapar en UnaryExpression som representerar ett undantagskast.
ToString()

Returnerar en textrepresentation av Expression.
TryCatch(Expression, CatchBlock[])

Skapar en TryExpression som representerar ett försöksblock med valfritt antal catch-instruktioner och varken ett fel eller slutligen blockering.
TryCatchFinally(Expression, Expression, CatchBlock[])

Skapar ett TryExpression som representerar ett försöksblock med valfritt antal catch-instruktioner och ett slutligen block.
TryFault(Expression, Expression)

Skapar ett TryExpression försöksblock som representerar ett försöksblock med ett felblock och inga catch-instruktioner.
TryFinally(Expression, Expression)

Skapar en TryExpression som representerar ett försöksblock med ett äntligen block och inga catch-instruktioner.
TryGetActionType(Type[], Type)

Skapar ett Type objekt som representerar en allmän System.Action-ombudstyp som har specifika typargument.
TryGetFuncType(Type[], Type)

Skapar ett Type objekt som representerar en allmän System.Func-ombudstyp som har specifika typargument. Det sista typargumentet anger returtypen för det skapade ombudet.
TypeAs(Expression, Type)

Skapar en UnaryExpression som representerar en explicit referens eller boxningskonvertering där null anges om konverteringen misslyckas.
TypeEqual(Expression, Type)

Skapar en TypeBinaryExpression som jämför körningstypidentitet.
TypeIs(Expression, Type)

Skapar en TypeBinaryExpression.
UnaryPlus(Expression, MethodInfo)

Skapar en UnaryExpression som representerar en unary plus-åtgärd.
UnaryPlus(Expression)

Skapar en UnaryExpression som representerar en unary plus-åtgärd.
Unbox(Expression, Type)

Skapar en UnaryExpression som representerar en explicit avboxning.
Variable(Type, String)

Skapar en ParameterExpression nod som kan användas för att identifiera en parameter eller en variabel i ett uttrycksträd.
Variable(Type)

Skapar en ParameterExpression nod som kan användas för att identifiera en parameter eller en variabel i ett uttrycksträd.
VisitChildren(ExpressionVisitor)

Minskar noden och anropar sedan besökarens ombud för det reducerade uttrycket. Metoden genererar ett undantag om noden inte är redukterbar.

Gäller för