Expression Expression Expression Expression Class

Definicja

Udostępnia klasę bazową, z którego są uzyskiwane klas, które reprezentują węzły drzewa wyrażeń.Provides the base class from which the classes that represent expression tree nodes are derived. Zawiera ona także static (Shared w języku Visual Basic) metodami factory, aby utworzyć różne typy węzłów.It also contains static (Shared in Visual Basic) factory methods to create the various node types. Jest to abstract klasy.This is an abstract class.

public ref class Expression abstract
public abstract class Expression
type Expression = class
Public MustInherit Class Expression
Dziedziczenie
ExpressionExpressionExpressionExpression
Pochodne

Przykłady

Poniższy przykład kodu pokazuje sposób tworzenia wyrażenia bloku.The following code example shows how to create a block expression. Wyrażenie bloku składa się z dwóch MethodCallExpression obiektów i jeden ConstantExpression obiektu.The block expression consists of two MethodCallExpression objects and one ConstantExpression object.

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

Konstruktory

Expression() Expression() Expression() Expression()

Tworzy nowe wystąpienie klasy Expression.Constructs a new instance of Expression.

Expression(ExpressionType, Type) Expression(ExpressionType, Type) Expression(ExpressionType, Type) Expression(ExpressionType, Type)

Inicjuje nowe wystąpienie klasy Expression klasy.Initializes a new instance of the Expression class.

Właściwości

CanReduce CanReduce CanReduce CanReduce

Wskazuje, że węzeł można zmniejszyć do węzła prostsze.Indicates that the node can be reduced to a simpler node. Jeśli zostanie zwrócona wartość true, można wywołać Reduce() powodować mniejsze formularza.If this returns true, Reduce() can be called to produce the reduced form.

NodeType NodeType NodeType NodeType

Pobiera typ węzła Expression.Gets the node type of this Expression.

Type Type Type Type

Pobiera typu statycznego wyrażenia, które to Expression reprezentuje.Gets the static type of the expression that this Expression represents.

Metody

Accept(ExpressionVisitor) Accept(ExpressionVisitor) Accept(ExpressionVisitor) Accept(ExpressionVisitor)

Wysyła do konkretnej można znaleźć metody dla tego typu węzła.Dispatches to the specific visit method for this node type. Na przykład MethodCallExpression wywołania VisitMethodCall(MethodCallExpression).For example, MethodCallExpression calls the VisitMethodCall(MethodCallExpression).

Add(Expression, Expression) Add(Expression, Expression) Add(Expression, Expression) Add(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację dodawania arytmetyczne, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic addition operation that does not have overflow checking.

Add(Expression, Expression, MethodInfo) Add(Expression, Expression, MethodInfo) Add(Expression, Expression, MethodInfo) Add(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację dodawania arytmetyczne, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic addition operation that does not have overflow checking. Implementowanie metoda może być określona.The implementing method can be specified.

AddAssign(Expression, Expression) AddAssign(Expression, Expression) AddAssign(Expression, Expression) AddAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację przypisania dodatku, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking.

AddAssign(Expression, Expression, MethodInfo) AddAssign(Expression, Expression, MethodInfo) AddAssign(Expression, Expression, MethodInfo) AddAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację przypisania dodatku, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking.

AddAssign(Expression, Expression, MethodInfo, LambdaExpression) AddAssign(Expression, Expression, MethodInfo, LambdaExpression) AddAssign(Expression, Expression, MethodInfo, LambdaExpression) AddAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację przypisania dodatku, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an addition assignment operation that does not have overflow checking.

AddAssignChecked(Expression, Expression) AddAssignChecked(Expression, Expression) AddAssignChecked(Expression, Expression) AddAssignChecked(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację przypisania dodawania, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an addition assignment operation that has overflow checking.

AddAssignChecked(Expression, Expression, MethodInfo) AddAssignChecked(Expression, Expression, MethodInfo) AddAssignChecked(Expression, Expression, MethodInfo) AddAssignChecked(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację przypisania dodawania, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an addition assignment operation that has overflow checking.

AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) AddAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację przypisania dodawania, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an addition assignment operation that has overflow checking.

AddChecked(Expression, Expression) AddChecked(Expression, Expression) AddChecked(Expression, Expression) AddChecked(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację dodawania arytmetyczne, która ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic addition operation that has overflow checking.

AddChecked(Expression, Expression, MethodInfo) AddChecked(Expression, Expression, MethodInfo) AddChecked(Expression, Expression, MethodInfo) AddChecked(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację dodawania arytmetyczne, która ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic addition operation that has overflow checking. Implementowanie metoda może być określona.The implementing method can be specified.

And(Expression, Expression) And(Expression, Expression) And(Expression, Expression) And(Expression, Expression)

Tworzy BinaryExpression reprezentujący bitowej AND operacji.Creates a BinaryExpression that represents a bitwise AND operation.

And(Expression, Expression, MethodInfo) And(Expression, Expression, MethodInfo) And(Expression, Expression, MethodInfo) And(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący bitowej AND operacji.Creates a BinaryExpression that represents a bitwise AND operation. Implementowanie metoda może być określona.The implementing method can be specified.

AndAlso(Expression, Expression) AndAlso(Expression, Expression) AndAlso(Expression, Expression) AndAlso(Expression, Expression)

Tworzy BinaryExpression reprezentujący warunkowe AND operacji, która ocenia drugi argument operacji tylko wtedy, gdy pierwszy operand ma wartość true.Creates a BinaryExpression that represents a conditional AND operation that evaluates the second operand only if the first operand evaluates to true.

AndAlso(Expression, Expression, MethodInfo) AndAlso(Expression, Expression, MethodInfo) AndAlso(Expression, Expression, MethodInfo) AndAlso(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący warunkowe AND operacji, która ocenia drugi argument operacji tylko wtedy, gdy jest to pierwszy argument nie zostanie rozwiązany na wartość true.Creates a BinaryExpression that represents a conditional AND operation that evaluates the second operand only if the first operand is resolved to true. Implementowanie metoda może być określona.The implementing method can be specified.

AndAssign(Expression, Expression) AndAssign(Expression, Expression) AndAssign(Expression, Expression) AndAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący bitowe operacji przypisania i.Creates a BinaryExpression that represents a bitwise AND assignment operation.

AndAssign(Expression, Expression, MethodInfo) AndAssign(Expression, Expression, MethodInfo) AndAssign(Expression, Expression, MethodInfo) AndAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący bitowe operacji przypisania i.Creates a BinaryExpression that represents a bitwise AND assignment operation.

AndAssign(Expression, Expression, MethodInfo, LambdaExpression) AndAssign(Expression, Expression, MethodInfo, LambdaExpression) AndAssign(Expression, Expression, MethodInfo, LambdaExpression) AndAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący bitowe operacji przypisania i.Creates a BinaryExpression that represents a bitwise AND assignment operation.

ArrayAccess(Expression, Expression[]) ArrayAccess(Expression, Expression[]) ArrayAccess(Expression, Expression[]) ArrayAccess(Expression, Expression[])

Tworzy IndexExpression dostępu do tablicy.Creates an IndexExpression to access an array.

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

Tworzy IndexExpression na dostęp do tablicy wielowymiarowej.Creates an IndexExpression to access a multidimensional array.

ArrayIndex(Expression, Expression) ArrayIndex(Expression, Expression) ArrayIndex(Expression, Expression) ArrayIndex(Expression, Expression)

Tworzy BinaryExpression reprezentujący zastosowania operatora indeksu tablicy do tablicy o rzędzie, jeden.Creates a BinaryExpression that represents applying an array index operator to an array of rank one.

ArrayIndex(Expression, Expression[]) ArrayIndex(Expression, Expression[]) ArrayIndex(Expression, Expression[]) ArrayIndex(Expression, Expression[])

Tworzy MethodCallExpression reprezentujący zastosowania operatora indeksu tablicy do tablicy wielowymiarowej.Creates a MethodCallExpression that represents applying an array index operator to a multidimensional array.

ArrayIndex(Expression, IEnumerable<Expression>) ArrayIndex(Expression, IEnumerable<Expression>) ArrayIndex(Expression, IEnumerable<Expression>) ArrayIndex(Expression, IEnumerable<Expression>)

Tworzy MethodCallExpression reprezentujący zastosowanie operatora indeksu tablicy do tablicy o randze więcej niż jeden port.Creates a MethodCallExpression that represents applying an array index operator to an array of rank more than one.

ArrayLength(Expression) ArrayLength(Expression) ArrayLength(Expression) ArrayLength(Expression)

Tworzy UnaryExpression reprezentujący wyrażenie do uzyskania długości tablicy jednowymiarowej.Creates a UnaryExpression that represents an expression for obtaining the length of a one-dimensional array.

Assign(Expression, Expression) Assign(Expression, Expression) Assign(Expression, Expression) Assign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operatora przypisania.Creates a BinaryExpression that represents an assignment operation.

Bind(MemberInfo, Expression) Bind(MemberInfo, Expression) Bind(MemberInfo, Expression) Bind(MemberInfo, Expression)

Tworzy MemberAssignment reprezentujący inicjowanie ona polem ani właściwością.Creates a MemberAssignment that represents the initialization of a field or property.

Bind(MethodInfo, Expression) Bind(MethodInfo, Expression) Bind(MethodInfo, Expression) Bind(MethodInfo, Expression)

Tworzy MemberAssignment reprezentujący inicjowania elementu członkowskiego za pomocą metody dostępu właściwości.Creates a MemberAssignment that represents the initialization of a member by using a property accessor method.

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

Tworzy BlockExpression , zawierający dwóch wyrażeń, a nie ma zmiennych.Creates a BlockExpression that contains two expressions and has no variables.

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

Tworzy BlockExpression , zawierający trzy wyrażenia, a nie ma zmiennych.Creates a BlockExpression that contains three expressions and has no variables.

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

Tworzy BlockExpression , zawierający cztery wyrażeń, a nie ma zmiennych.Creates a BlockExpression that contains four expressions and has no variables.

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

Tworzy BlockExpression , zawierający pięć wyrażeń, a nie ma zmiennych.Creates a BlockExpression that contains five expressions and has no variables.

Block(Expression[]) Block(Expression[]) Block(Expression[]) Block(Expression[])

Tworzy BlockExpression , zawierający danego wyrażenia, a nie ma zmiennych.Creates a BlockExpression that contains the given expressions and has no variables.

Block(IEnumerable<Expression>) Block(IEnumerable<Expression>) Block(IEnumerable<Expression>) Block(IEnumerable<Expression>)

Tworzy BlockExpression , zawierający danego wyrażenia, a nie ma zmiennych.Creates a BlockExpression that contains the given expressions and has no variables.

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

Tworzy BlockExpression zawierający dany zmiennych i wyrażeń.Creates a BlockExpression that contains the given variables and expressions.

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

Tworzy BlockExpression zawierający dany zmiennych i wyrażeń.Creates a BlockExpression that contains the given variables and expressions.

Block(Type, Expression[]) Block(Type, Expression[]) Block(Type, Expression[]) Block(Type, Expression[])

Tworzy BlockExpression , zawierający danego wyrażenia, nie ma zmiennych, a ma typ konkretnego wyniku.Creates a BlockExpression that contains the given expressions, has no variables and has specific result type.

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

Tworzy BlockExpression , zawierający danego wyrażenia, nie ma zmiennych, a ma typ konkretnego wyniku.Creates a BlockExpression that contains the given expressions, has no variables and has specific result type.

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

Tworzy BlockExpression zawierający dany zmiennych i wyrażeń.Creates a BlockExpression that contains the given variables and expressions.

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

Tworzy BlockExpression zawierający dany zmiennych i wyrażeń.Creates a BlockExpression that contains the given variables and expressions.

Break(LabelTarget) Break(LabelTarget) Break(LabelTarget) Break(LabelTarget)

Tworzy GotoExpression reprezentujący instrukcji break.Creates a GotoExpression representing a break statement.

Break(LabelTarget, Expression) Break(LabelTarget, Expression) Break(LabelTarget, Expression) Break(LabelTarget, Expression)

Tworzy GotoExpression reprezentujący instrukcji break.Creates a GotoExpression representing a break statement. Można określić wartość przekazana do etykiety na skok.The value passed to the label upon jumping can be specified.

Break(LabelTarget, Expression, Type) Break(LabelTarget, Expression, Type) Break(LabelTarget, Expression, Type) Break(LabelTarget, Expression, Type)

Tworzy GotoExpression reprezentujący instrukcji break z określonym typem.Creates a GotoExpression representing a break statement with the specified type. Można określić wartość przekazana do etykiety na skok.The value passed to the label upon jumping can be specified.

Break(LabelTarget, Type) Break(LabelTarget, Type) Break(LabelTarget, Type) Break(LabelTarget, Type)

Tworzy GotoExpression reprezentujący instrukcji break z określonym typem.Creates a GotoExpression representing a break statement with the specified type.

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

Tworzy MethodCallExpression reprezentujący wywołanie do metody, która nie przyjmuje żadnych argumentów.Creates a MethodCallExpression that represents a call to a method that takes no arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie do metody, która przyjmuje dwa argumenty.Creates a MethodCallExpression that represents a call to a method that takes two arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie metody, która przyjmuje trzy argumenty.Creates a MethodCallExpression that represents a call to a method that takes three arguments.

Call(Expression, MethodInfo, Expression[]) Call(Expression, MethodInfo, Expression[]) Call(Expression, MethodInfo, Expression[]) Call(Expression, MethodInfo, Expression[])

Tworzy MethodCallExpression reprezentujący wywołanie do metody, która przyjmuje argumenty.Creates a MethodCallExpression that represents a call to a method that takes arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie do metody, która przyjmuje argumenty.Creates a MethodCallExpression that represents a call to a method that takes arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie do metody za pomocą wywołania metody odpowiedniej fabryki.Creates a MethodCallExpression that represents a call to a method by calling the appropriate factory method.

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

Tworzy MethodCallExpression reprezentujący wywołanie static (Shared w języku Visual Basic) metoda, która przyjmuje jeden argument.Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method that takes one argument.

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

Tworzy MethodCallExpression reprezentujący wywołanie metody statycznej, która przyjmuje dwa argumenty.Creates a MethodCallExpression that represents a call to a static method that takes two arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie metody statycznej, która przyjmuje trzy argumenty.Creates a MethodCallExpression that represents a call to a static method that takes three arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie metody statycznej, która przyjmuje cztery argumenty.Creates a MethodCallExpression that represents a call to a static method that takes four arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie metody statycznej, która przyjmuje argumenty.Creates a MethodCallExpression that represents a call to a static method that takes five arguments.

Call(MethodInfo, Expression[]) Call(MethodInfo, Expression[]) Call(MethodInfo, Expression[]) Call(MethodInfo, Expression[])

Tworzy MethodCallExpression reprezentujący wywołanie static (Shared w języku Visual Basic) metoda, która przyjmuje argumenty.Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method that has arguments.

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

Tworzy MethodCallExpression reprezentujący wywołanie do metody statyczne (Shared w języku Visual Basic).Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method.

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

Tworzy MethodCallExpression reprezentujący wywołanie static (Shared w języku Visual Basic) metoda, przez wywołanie metody odpowiedniej fabryki.Creates a MethodCallExpression that represents a call to a static (Shared in Visual Basic) method by calling the appropriate factory method.

Catch(ParameterExpression, Expression) Catch(ParameterExpression, Expression) Catch(ParameterExpression, Expression) Catch(ParameterExpression, Expression)

Tworzy CatchBlock reprezentujący instrukcję catch w odniesieniu do przechwyconego Exception obiekt do użycia w treści procedury obsługi.Creates a CatchBlock representing a catch statement with a reference to the caught Exception object for use in the handler body.

Catch(ParameterExpression, Expression, Expression) Catch(ParameterExpression, Expression, Expression) Catch(ParameterExpression, Expression, Expression) Catch(ParameterExpression, Expression, Expression)

Tworzy CatchBlock reprezentujący instrukcję catch Exception filtr i odwołania do przechwyconego Exception obiektu.Creates a CatchBlock representing a catch statement with an Exception filter and a reference to the caught Exception object.

Catch(Type, Expression) Catch(Type, Expression) Catch(Type, Expression) Catch(Type, Expression)

Tworzy CatchBlock reprezentujący instrukcję catch.Creates a CatchBlock representing a catch statement.

Catch(Type, Expression, Expression) Catch(Type, Expression, Expression) Catch(Type, Expression, Expression) Catch(Type, Expression, Expression)

Tworzy CatchBlock reprezentujący instrukcję catch Exception filtru, ale brak odwołania do przechwyconego Exception obiektu.Creates a CatchBlock representing a catch statement with an Exception filter but no reference to the caught Exception object.

ClearDebugInfo(SymbolDocumentInfo) ClearDebugInfo(SymbolDocumentInfo) ClearDebugInfo(SymbolDocumentInfo) ClearDebugInfo(SymbolDocumentInfo)

Tworzy DebugInfoExpression czyszczenia punktu sekwencji.Creates a DebugInfoExpression for clearing a sequence point.

Coalesce(Expression, Expression) Coalesce(Expression, Expression) Coalesce(Expression, Expression) Coalesce(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację łączącego.Creates a BinaryExpression that represents a coalescing operation.

Coalesce(Expression, Expression, LambdaExpression) Coalesce(Expression, Expression, LambdaExpression) Coalesce(Expression, Expression, LambdaExpression) Coalesce(Expression, Expression, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację łączącego, biorąc pod uwagę funkcji konwersji.Creates a BinaryExpression that represents a coalescing operation, given a conversion function.

Condition(Expression, Expression, Expression) Condition(Expression, Expression, Expression) Condition(Expression, Expression, Expression) Condition(Expression, Expression, Expression)

Tworzy ConditionalExpression reprezentujący instrukcji warunkowej.Creates a ConditionalExpression that represents a conditional statement.

Condition(Expression, Expression, Expression, Type) Condition(Expression, Expression, Expression, Type) Condition(Expression, Expression, Expression, Type) Condition(Expression, Expression, Expression, Type)

Tworzy ConditionalExpression reprezentujący instrukcji warunkowej.Creates a ConditionalExpression that represents a conditional statement.

Constant(Object) Constant(Object) Constant(Object) Constant(Object)

Tworzy ConstantExpression zawierający Value właściwość o określonej wartości.Creates a ConstantExpression that has the Value property set to the specified value.

Constant(Object, Type) Constant(Object, Type) Constant(Object, Type) Constant(Object, Type)

Tworzy ConstantExpression zawierający Value i Type równa określonej wartości właściwości.Creates a ConstantExpression that has the Value and Type properties set to the specified values.

Continue(LabelTarget) Continue(LabelTarget) Continue(LabelTarget) Continue(LabelTarget)

Tworzy GotoExpression reprezentujący instrukcji continue.Creates a GotoExpression representing a continue statement.

Continue(LabelTarget, Type) Continue(LabelTarget, Type) Continue(LabelTarget, Type) Continue(LabelTarget, Type)

Tworzy GotoExpression reprezentujący instrukcji continue z określonym typem.Creates a GotoExpression representing a continue statement with the specified type.

Convert(Expression, Type) Convert(Expression, Type) Convert(Expression, Type) Convert(Expression, Type)

Tworzy UnaryExpression reprezentujący operację konwersji typu.Creates a UnaryExpression that represents a type conversion operation.

Convert(Expression, Type, MethodInfo) Convert(Expression, Type, MethodInfo) Convert(Expression, Type, MethodInfo) Convert(Expression, Type, MethodInfo)

Tworzy UnaryExpression reprezentujący operację konwersji, dla którego określono implementującej metody.Creates a UnaryExpression that represents a conversion operation for which the implementing method is specified.

ConvertChecked(Expression, Type) ConvertChecked(Expression, Type) ConvertChecked(Expression, Type) ConvertChecked(Expression, Type)

Tworzy UnaryExpression reprezentujący operację konwersji, która zgłosiła wyjątek, jeśli typ docelowy jest przepełniony.Creates a UnaryExpression that represents a conversion operation that throws an exception if the target type is overflowed.

ConvertChecked(Expression, Type, MethodInfo) ConvertChecked(Expression, Type, MethodInfo) ConvertChecked(Expression, Type, MethodInfo) ConvertChecked(Expression, Type, MethodInfo)

Tworzy UnaryExpression reprezentujący operację konwersji, która zgłosiła wyjątek, jeśli typ docelowy jest przepełniony i dla którego określono implementującej metody.Creates a UnaryExpression that represents a conversion operation that throws an exception if the target type is overflowed and for which the implementing method is specified.

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

Tworzy DebugInfoExpression z określonym zakresem.Creates a DebugInfoExpression with the specified span.

Decrement(Expression) Decrement(Expression) Decrement(Expression) Decrement(Expression)

Tworzy UnaryExpression reprezentujący zmniejszanie wyrażenia o 1.Creates a UnaryExpression that represents the decrementing of the expression by 1.

Decrement(Expression, MethodInfo) Decrement(Expression, MethodInfo) Decrement(Expression, MethodInfo) Decrement(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący zmniejszanie wyrażenia o 1.Creates a UnaryExpression that represents the decrementing of the expression by 1.

Default(Type) Default(Type) Default(Type) Default(Type)

Tworzy DefaultExpression zawierający Type właściwość o określonym typie.Creates a DefaultExpression that has the Type property set to the specified type.

Divide(Expression, Expression) Divide(Expression, Expression) Divide(Expression, Expression) Divide(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację arytmetycznego dzielenia.Creates a BinaryExpression that represents an arithmetic division operation.

Divide(Expression, Expression, MethodInfo) Divide(Expression, Expression, MethodInfo) Divide(Expression, Expression, MethodInfo) Divide(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację arytmetycznego dzielenia.Creates a BinaryExpression that represents an arithmetic division operation. Implementowanie metoda może być określona.The implementing method can be specified.

DivideAssign(Expression, Expression) DivideAssign(Expression, Expression) DivideAssign(Expression, Expression) DivideAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację przypisanie dzielenia, które ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking.

DivideAssign(Expression, Expression, MethodInfo) DivideAssign(Expression, Expression, MethodInfo) DivideAssign(Expression, Expression, MethodInfo) DivideAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację przypisanie dzielenia, które ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking.

DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) DivideAssign(Expression, Expression, MethodInfo, LambdaExpression) DivideAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację przypisanie dzielenia, które ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a division assignment operation that does not have overflow checking.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

Dynamic(CallSiteBinder, Type, Expression[]) Dynamic(CallSiteBinder, Type, Expression[]) Dynamic(CallSiteBinder, Type, Expression[]) Dynamic(CallSiteBinder, Type, Expression[])

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

ElementInit(MethodInfo, Expression[]) ElementInit(MethodInfo, Expression[]) ElementInit(MethodInfo, Expression[]) ElementInit(MethodInfo, Expression[])

Tworzy ElementInit, biorąc pod uwagę tablicę wartości, jako drugi argument.Creates an ElementInit, given an array of values as the second argument.

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

Tworzy ElementInit, danego IEnumerable<T> jako drugi argument.Creates an ElementInit, given an IEnumerable<T> as the second argument.

Empty() Empty() Empty() Empty()

Tworzy puste wyrażenie, które ma Void typu.Creates an empty expression that has Void type.

Equal(Expression, Expression) Equal(Expression, Expression) Equal(Expression, Expression) Equal(Expression, Expression)

Tworzy BinaryExpression reprezentujący porównanie równości.Creates a BinaryExpression that represents an equality comparison.

Equal(Expression, Expression, Boolean, MethodInfo) Equal(Expression, Expression, Boolean, MethodInfo) Equal(Expression, Expression, Boolean, MethodInfo) Equal(Expression, Expression, Boolean, MethodInfo)

Tworzy BinaryExpression reprezentujący porównanie równości.Creates a BinaryExpression that represents an equality comparison. Implementowanie metoda może być określona.The implementing method can be specified.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Inherited from Object)
ExclusiveOr(Expression, Expression) ExclusiveOr(Expression, Expression) ExclusiveOr(Expression, Expression) ExclusiveOr(Expression, Expression)

Tworzy BinaryExpression reprezentujący bitowej XOR operacji przy użyciu op_exclusiveor — dla typów zdefiniowanych przez użytkownika.Creates a BinaryExpression that represents a bitwise XOR operation, using op_ExclusiveOr for user-defined types.

ExclusiveOr(Expression, Expression, MethodInfo) ExclusiveOr(Expression, Expression, MethodInfo) ExclusiveOr(Expression, Expression, MethodInfo) ExclusiveOr(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący bitowej XOR operacji przy użyciu op_exclusiveor — dla typów zdefiniowanych przez użytkownika.Creates a BinaryExpression that represents a bitwise XOR operation, using op_ExclusiveOr for user-defined types. Implementowanie metoda może być określona.The implementing method can be specified.

ExclusiveOrAssign(Expression, Expression) ExclusiveOrAssign(Expression, Expression) ExclusiveOrAssign(Expression, Expression) ExclusiveOrAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację przypisania bitowe XOR przy użyciu op_exclusiveor — dla typów zdefiniowanych przez użytkownika.Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types.

ExclusiveOrAssign(Expression, Expression, MethodInfo) ExclusiveOrAssign(Expression, Expression, MethodInfo) ExclusiveOrAssign(Expression, Expression, MethodInfo) ExclusiveOrAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację przypisania bitowe XOR przy użyciu op_exclusiveor — dla typów zdefiniowanych przez użytkownika.Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types.

ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression) ExclusiveOrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację przypisania bitowe XOR przy użyciu op_exclusiveor — dla typów zdefiniowanych przez użytkownika.Creates a BinaryExpression that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types.

Field(Expression, FieldInfo) Field(Expression, FieldInfo) Field(Expression, FieldInfo) Field(Expression, FieldInfo)

Tworzy MemberExpression reprezentująca dostęp do pola.Creates a MemberExpression that represents accessing a field.

Field(Expression, String) Field(Expression, String) Field(Expression, String) Field(Expression, String)

Tworzy MemberExpression reprezentująca dostęp do pola, biorąc pod uwagę nazwę pola.Creates a MemberExpression that represents accessing a field given the name of the field.

Field(Expression, Type, String) Field(Expression, Type, String) Field(Expression, Type, String) Field(Expression, Type, String)

Tworzy MemberExpression reprezentująca dostęp do pola.Creates a MemberExpression that represents accessing a field.

GetActionType(Type[]) GetActionType(Type[]) GetActionType(Type[]) GetActionType(Type[])

Tworzy Type obiekt, który reprezentuje ogólnego elementu System.Action przekazać typ, który zawiera argumenty określonego typu.Creates a Type object that represents a generic System.Action delegate type that has specific type arguments.

GetDelegateType(Type[]) GetDelegateType(Type[]) GetDelegateType(Type[]) GetDelegateType(Type[])

Pobiera Type obiekt, który reprezentuje ogólnego System.Func lub elementu System.Action przekazać typ, który zawiera argumenty określonego typu.Gets a Type object that represents a generic System.Func or System.Action delegate type that has specific type arguments.

GetFuncType(Type[]) GetFuncType(Type[]) GetFuncType(Type[]) GetFuncType(Type[])

Tworzy Type obiekt, który reprezentuje ogólnego System.Func przekazać typ, który zawiera argumenty określonego typu.Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. Ostatni argument typu określa zwracany typ delegata utworzony.The last type argument specifies the return type of the created delegate.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Służy jako domyślnej funkcji skrótu.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Inherited from Object)
Goto(LabelTarget) Goto(LabelTarget) Goto(LabelTarget) Goto(LabelTarget)

Tworzy GotoExpression reprezentujący instrukcję "Przejdź do".Creates a GotoExpression representing a "go to" statement.

Goto(LabelTarget, Expression) Goto(LabelTarget, Expression) Goto(LabelTarget, Expression) Goto(LabelTarget, Expression)

Tworzy GotoExpression reprezentujący instrukcję "Przejdź do".Creates a GotoExpression representing a "go to" statement. Można określić wartość przekazana do etykiety na skok.The value passed to the label upon jumping can be specified.

Goto(LabelTarget, Expression, Type) Goto(LabelTarget, Expression, Type) Goto(LabelTarget, Expression, Type) Goto(LabelTarget, Expression, Type)

Tworzy GotoExpression reprezentujący instrukcję "Przejdź do" z określonym typem.Creates a GotoExpression representing a "go to" statement with the specified type. Można określić wartość przekazana do etykiety na skok.The value passed to the label upon jumping can be specified.

Goto(LabelTarget, Type) Goto(LabelTarget, Type) Goto(LabelTarget, Type) Goto(LabelTarget, Type)

Tworzy GotoExpression reprezentujący instrukcję "Przejdź do" z określonym typem.Creates a GotoExpression representing a "go to" statement with the specified type.

GreaterThan(Expression, Expression) GreaterThan(Expression, Expression) GreaterThan(Expression, Expression) GreaterThan(Expression, Expression)

Tworzy BinaryExpression reprezentujący "większe niż" porównanie numeryczne.Creates a BinaryExpression that represents a "greater than" numeric comparison.

GreaterThan(Expression, Expression, Boolean, MethodInfo) GreaterThan(Expression, Expression, Boolean, MethodInfo) GreaterThan(Expression, Expression, Boolean, MethodInfo) GreaterThan(Expression, Expression, Boolean, MethodInfo)

Tworzy BinaryExpression reprezentujący "większe niż" porównanie numeryczne.Creates a BinaryExpression that represents a "greater than" numeric comparison. Implementowanie metoda może być określona.The implementing method can be specified.

GreaterThanOrEqual(Expression, Expression) GreaterThanOrEqual(Expression, Expression) GreaterThanOrEqual(Expression, Expression) GreaterThanOrEqual(Expression, Expression)

Tworzy BinaryExpression reprezentujący "większe lub równe" porównanie numeryczne.Creates a BinaryExpression that represents a "greater than or equal" numeric comparison.

GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo) GreaterThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Tworzy BinaryExpression reprezentujący "większe lub równe" porównanie numeryczne.Creates a BinaryExpression that represents a "greater than or equal" numeric comparison.

IfThen(Expression, Expression) IfThen(Expression, Expression) IfThen(Expression, Expression) IfThen(Expression, Expression)

Tworzy ConditionalExpression reprezentujący bloku warunkowego za pomocą if instrukcji.Creates a ConditionalExpression that represents a conditional block with an if statement.

IfThenElse(Expression, Expression, Expression) IfThenElse(Expression, Expression, Expression) IfThenElse(Expression, Expression, Expression) IfThenElse(Expression, Expression, Expression)

Tworzy ConditionalExpression reprezentujący bloku warunkowego za pomocą if i else instrukcji.Creates a ConditionalExpression that represents a conditional block with if and else statements.

Increment(Expression) Increment(Expression) Increment(Expression) Increment(Expression)

Tworzy UnaryExpression reprezentujący zwiększenie wartości wyrażenia o 1.Creates a UnaryExpression that represents the incrementing of the expression value by 1.

Increment(Expression, MethodInfo) Increment(Expression, MethodInfo) Increment(Expression, MethodInfo) Increment(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący, zwiększając wartość wyrażenia o 1.Creates a UnaryExpression that represents the incrementing of the expression by 1.

Invoke(Expression, Expression[]) Invoke(Expression, Expression[]) Invoke(Expression, Expression[]) Invoke(Expression, Expression[])

Tworzy InvocationExpression delegat lub wyrażenie lambda która odnosi się do listy wyrażenia argumentu.Creates an InvocationExpression that applies a delegate or lambda expression to a list of argument expressions.

Invoke(Expression, IEnumerable<Expression>) Invoke(Expression, IEnumerable<Expression>) Invoke(Expression, IEnumerable<Expression>) Invoke(Expression, IEnumerable<Expression>)

Tworzy InvocationExpression delegat lub wyrażenie lambda która odnosi się do listy wyrażenia argumentu.Creates an InvocationExpression that applies a delegate or lambda expression to a list of argument expressions.

IsFalse(Expression) IsFalse(Expression) IsFalse(Expression) IsFalse(Expression)

Zwraca, czy wyrażenie zwróci wartość false.Returns whether the expression evaluates to false.

IsFalse(Expression, MethodInfo) IsFalse(Expression, MethodInfo) IsFalse(Expression, MethodInfo) IsFalse(Expression, MethodInfo)

Zwraca, czy wyrażenie zwróci wartość false.Returns whether the expression evaluates to false.

IsTrue(Expression) IsTrue(Expression) IsTrue(Expression) IsTrue(Expression)

Zwraca, czy wyrażenie ma wartość true.Returns whether the expression evaluates to true.

IsTrue(Expression, MethodInfo) IsTrue(Expression, MethodInfo) IsTrue(Expression, MethodInfo) IsTrue(Expression, MethodInfo)

Zwraca, czy wyrażenie ma wartość true.Returns whether the expression evaluates to true.

Label() Label() Label() Label()

Tworzy LabelTarget reprezentujący etykietę o typie void i bez nazwy.Creates a LabelTarget representing a label with void type and no name.

Label(LabelTarget) Label(LabelTarget) Label(LabelTarget) Label(LabelTarget)

Tworzy LabelExpression reprezentujący etykiety bez wartości domyślnej.Creates a LabelExpression representing a label without a default value.

Label(LabelTarget, Expression) Label(LabelTarget, Expression) Label(LabelTarget, Expression) Label(LabelTarget, Expression)

Tworzy LabelExpression reprezentujący etykietę z daną wartość domyślną.Creates a LabelExpression representing a label with the given default value.

Label(String) Label(String) Label(String) Label(String)

Tworzy LabelTarget reprezentujący etykietę o typie void i podanej nazwie.Creates a LabelTarget representing a label with void type and the given name.

Label(Type) Label(Type) Label(Type) Label(Type)

Tworzy LabelTarget reprezentujący etykiety z danym typem.Creates a LabelTarget representing a label with the given type.

Label(Type, String) Label(Type, String) Label(Type, String) Label(Type, String)

Tworzy LabelTarget reprezentujący etykiety z danym typem i nazwą.Creates a LabelTarget representing a label with the given type and name.

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

Tworzy LambdaExpression przy pierwszym konstruowanie z typem delegata z treści wyrażenia, parametr, który wskazuje, czy zostaną zastosowane optymalizację wywołania tail i wyliczalny zbiór parametrów wyrażenia.Creates a LambdaExpression by first constructing a delegate type from the expression body, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions. Można używać, gdy typ delegata nie jest znany w czasie kompilacji.It can be used when the delegate type is not known at compile time.

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

Tworzy LambdaExpression przy pierwszym konstruowanie z typem delegata z treści wyrażenia, parametr, który wskazuje, czy zostaną zastosowane optymalizację wywołania tail i tablicę w wyrażeniach parametrów.Creates a LambdaExpression by first constructing a delegate type from the expression body, a parameter that indicates whether tail call optimization will be applied, and an array of parameter expressions. Można używać, gdy typ delegata nie jest znany w czasie kompilacji.It can be used when the delegate type is not known at compile time.

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

Tworzy LambdaExpression przy pierwszym konstruowanie typ obiektu delegowanego z treści wyrażenia i wyliczalny zbiór parametrów wyrażenia.Creates a LambdaExpression by first constructing a delegate type from the expression body, and an enumerable collection of parameter expressions. Można używać, gdy typ delegata nie jest znany w czasie kompilacji.It can be used when the delegate type is not known at compile time.

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

Tworzy LambdaExpression przy pierwszym konstruowanie typ obiektu delegowanego z treści wyrażenia i tablicę w wyrażeniach parametrów.Creates a LambdaExpression by first constructing a delegate type from the expression body, and an array of parameter expressions. Można używać, gdy typ delegata nie jest znany w czasie kompilacji.It can be used when the delegate type is not known at compile time.

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

Tworzy LambdaExpression przy pierwszym konstruowanie z typem delegata z treści wyrażenia, nazwę dla wyrażenia lambda, parametr, który wskazuje, czy zostaną zastosowane optymalizację wywołania tail i wyliczalny zbiór parametrów wyrażenia.Creates a LambdaExpression by first constructing a delegate type from the expression body, the name for the lambda, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions. Można używać, gdy typ delegata nie jest znany w czasie kompilacji.It can be used when the delegate type is not known at compile time.

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

Tworzy LambdaExpression przy pierwszym konstruowanie z typem delegata z treści wyrażenia, nazwę dla wyrażenia lambda i wyliczalny zbiór parametrów wyrażenia.Creates a LambdaExpression by first constructing a delegate type from the expression body, the name for the lambda, and an enumerable collection of parameter expressions. Można używać, gdy typ delegata nie jest znany w czasie kompilacji.It can be used when the delegate type is not known at compile time.

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

Tworzy LambdaExpression której typ delegata jest znany w czasie kompilacji, za pomocą parametru, która wskazuje, czy zostaną zastosowane optymalizację wywołania tail i wyliczalny zbiór parametrów wyrażenia.Creates a LambdaExpression where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

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

Tworzy LambdaExpression której typ delegata jest znany w czasie kompilacji, za pomocą parametru, która wskazuje, czy zostaną zastosowane optymalizację wywołania tail i tablicę w wyrażeniach parametrów.Creates a LambdaExpression where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an array of parameter expressions.

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

Tworzy LambdaExpression gdzie typ delegata jest znany w czasie kompilacji z kolekcją wyliczalny wyrażeń parametru.Creates a LambdaExpression where the delegate type is known at compile time, with an enumerable collection of parameter expressions.

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

Tworzy LambdaExpression której typ delegata jest znany w czasie kompilacji, z tablicą parametrów wyrażenia.Creates a LambdaExpression where the delegate type is known at compile time, with an array of parameter expressions.

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

Tworzy LambdaExpression której typ delegata jest znany w czasie kompilacji, o nazwie lambda, parametr, który wskazuje, czy zostaną zastosowane optymalizację wywołania tail i wyliczalny zbiór wyrażeniach parametrów.Creates a LambdaExpression where the delegate type is known at compile time, with the name for the lambda, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

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

Tworzy LambdaExpression której typ delegata jest znany w czasie kompilacji, o nazwie dla wyrażenia lambda i wyliczalny zbiór parametrów wyrażenia.Creates a LambdaExpression where the delegate type is known at compile time, with the name for the lambda, and an enumerable collection of parameter expressions.

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

Tworzy Expression<TDelegate> której typ delegata jest znany w czasie kompilacji, za pomocą parametru, która wskazuje, czy zostaną zastosowane optymalizację wywołania tail i wyliczalny zbiór parametrów wyrażenia.Creates an Expression<TDelegate> where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

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

Tworzy Expression<TDelegate> której typ delegata jest znany w czasie kompilacji, za pomocą parametru, która wskazuje, czy zostaną zastosowane optymalizację wywołania tail i tablicę w wyrażeniach parametrów.Creates an Expression<TDelegate> where the delegate type is known at compile time, with a parameter that indicates whether tail call optimization will be applied, and an array of parameter expressions.

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

Tworzy Expression<TDelegate> gdzie typ delegata jest znany w czasie kompilacji z kolekcją wyliczalny wyrażeń parametru.Creates an Expression<TDelegate> where the delegate type is known at compile time, with an enumerable collection of parameter expressions.

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

Tworzy Expression<TDelegate> której typ delegata jest znany w czasie kompilacji, z tablicą parametrów wyrażenia.Creates an Expression<TDelegate> where the delegate type is known at compile time, with an array of parameter expressions.

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

Tworzy Expression<TDelegate> której typ delegata jest znany w czasie kompilacji, o nazwie lambda, parametr, który wskazuje, czy zostaną zastosowane optymalizację wywołania tail i wyliczalny zbiór wyrażeniach parametrów.Creates an Expression<TDelegate> where the delegate type is known at compile time, with the name for the lambda, a parameter that indicates whether tail call optimization will be applied, and an enumerable collection of parameter expressions.

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

Tworzy Expression<TDelegate> której typ delegata jest znany w czasie kompilacji, o nazwie dla wyrażenia lambda i wyliczalny zbiór parametrów wyrażenia.Creates an Expression<TDelegate> where the delegate type is known at compile time, with the name for the lambda, and an enumerable collection of parameter expressions.

LeftShift(Expression, Expression) LeftShift(Expression, Expression) LeftShift(Expression, Expression) LeftShift(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację bitowego przesunięcia w lewo.Creates a BinaryExpression that represents a bitwise left-shift operation.

LeftShift(Expression, Expression, MethodInfo) LeftShift(Expression, Expression, MethodInfo) LeftShift(Expression, Expression, MethodInfo) LeftShift(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację bitowego przesunięcia w lewo.Creates a BinaryExpression that represents a bitwise left-shift operation.

LeftShiftAssign(Expression, Expression) LeftShiftAssign(Expression, Expression) LeftShiftAssign(Expression, Expression) LeftShiftAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację logiczną przypisania przesunięcia w lewo.Creates a BinaryExpression that represents a bitwise left-shift assignment operation.

LeftShiftAssign(Expression, Expression, MethodInfo) LeftShiftAssign(Expression, Expression, MethodInfo) LeftShiftAssign(Expression, Expression, MethodInfo) LeftShiftAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację logiczną przypisania przesunięcia w lewo.Creates a BinaryExpression that represents a bitwise left-shift assignment operation.

LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) LeftShiftAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację logiczną przypisania przesunięcia w lewo.Creates a BinaryExpression that represents a bitwise left-shift assignment operation.

LessThan(Expression, Expression) LessThan(Expression, Expression) LessThan(Expression, Expression) LessThan(Expression, Expression)

Tworzy BinaryExpression reprezentujący "poniżej" porównanie numeryczne.Creates a BinaryExpression that represents a "less than" numeric comparison.

LessThan(Expression, Expression, Boolean, MethodInfo) LessThan(Expression, Expression, Boolean, MethodInfo) LessThan(Expression, Expression, Boolean, MethodInfo) LessThan(Expression, Expression, Boolean, MethodInfo)

Tworzy BinaryExpression reprezentujący "poniżej" porównanie numeryczne.Creates a BinaryExpression that represents a "less than" numeric comparison.

LessThanOrEqual(Expression, Expression) LessThanOrEqual(Expression, Expression) LessThanOrEqual(Expression, Expression) LessThanOrEqual(Expression, Expression)

Tworzy BinaryExpression reprezentujący "mniejsze niż lub równe" porównanie numeryczne.Creates a BinaryExpression that represents a " less than or equal" numeric comparison.

LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) LessThanOrEqual(Expression, Expression, Boolean, MethodInfo) LessThanOrEqual(Expression, Expression, Boolean, MethodInfo)

Tworzy BinaryExpression reprezentujący "mniejsze niż lub równe" porównanie numeryczne.Creates a BinaryExpression that represents a "less than or equal" numeric comparison.

ListBind(MemberInfo, ElementInit[]) ListBind(MemberInfo, ElementInit[]) ListBind(MemberInfo, ElementInit[]) ListBind(MemberInfo, ElementInit[])

Tworzy MemberListBinding gdzie element członkowski jest ona polem ani właściwością.Creates a MemberListBinding where the member is a field or property.

ListBind(MemberInfo, IEnumerable<ElementInit>) ListBind(MemberInfo, IEnumerable<ElementInit>) ListBind(MemberInfo, IEnumerable<ElementInit>) ListBind(MemberInfo, IEnumerable<ElementInit>)

Tworzy MemberListBinding gdzie element członkowski jest ona polem ani właściwością.Creates a MemberListBinding where the member is a field or property.

ListBind(MethodInfo, ElementInit[]) ListBind(MethodInfo, ElementInit[]) ListBind(MethodInfo, ElementInit[]) ListBind(MethodInfo, ElementInit[])

Tworzy MemberListBinding obiektu na podstawie określonej właściwości metody dostępu metody.Creates a MemberListBinding object based on a specified property accessor method.

ListBind(MethodInfo, IEnumerable<ElementInit>) ListBind(MethodInfo, IEnumerable<ElementInit>) ListBind(MethodInfo, IEnumerable<ElementInit>) ListBind(MethodInfo, IEnumerable<ElementInit>)

Tworzy MemberListBinding na podstawie metody dostępu określonej właściwości.Creates a MemberListBinding based on a specified property accessor method.

ListInit(NewExpression, ElementInit[]) ListInit(NewExpression, ElementInit[]) ListInit(NewExpression, ElementInit[]) ListInit(NewExpression, ElementInit[])

Tworzy ListInitExpression używającego określony ElementInit obiekty do zainicjowania kolekcji.Creates a ListInitExpression that uses specified ElementInit objects to initialize a collection.

ListInit(NewExpression, Expression[]) ListInit(NewExpression, Expression[]) ListInit(NewExpression, Expression[]) ListInit(NewExpression, Expression[])

Tworzy ListInitExpression korzystającą metodę o nazwie "Add", aby dodać elementy do kolekcji.Creates a ListInitExpression that uses a method named "Add" to add elements to a collection.

ListInit(NewExpression, IEnumerable<ElementInit>) ListInit(NewExpression, IEnumerable<ElementInit>) ListInit(NewExpression, IEnumerable<ElementInit>) ListInit(NewExpression, IEnumerable<ElementInit>)

Tworzy ListInitExpression używającego określony ElementInit obiekty do zainicjowania kolekcji.Creates a ListInitExpression that uses specified ElementInit objects to initialize a collection.

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

Tworzy ListInitExpression korzystającą metodę o nazwie "Add", aby dodać elementy do kolekcji.Creates a ListInitExpression that uses a method named "Add" to add elements to a collection.

ListInit(NewExpression, MethodInfo, Expression[]) ListInit(NewExpression, MethodInfo, Expression[]) ListInit(NewExpression, MethodInfo, Expression[]) ListInit(NewExpression, MethodInfo, Expression[])

Tworzy ListInitExpression , używa określonej metody dodawania elementów do kolekcji.Creates a ListInitExpression that uses a specified method to add elements to a collection.

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

Tworzy ListInitExpression , używa określonej metody dodawania elementów do kolekcji.Creates a ListInitExpression that uses a specified method to add elements to a collection.

Loop(Expression) Loop(Expression) Loop(Expression) Loop(Expression)

Tworzy LoopExpression danej jednostki.Creates a LoopExpression with the given body.

Loop(Expression, LabelTarget) Loop(Expression, LabelTarget) Loop(Expression, LabelTarget) Loop(Expression, LabelTarget)

Tworzy LoopExpression z danym elementem docelowym treści i podziału.Creates a LoopExpression with the given body and break target.

Loop(Expression, LabelTarget, LabelTarget) Loop(Expression, LabelTarget, LabelTarget) Loop(Expression, LabelTarget, LabelTarget) Loop(Expression, LabelTarget, LabelTarget)

Tworzy LoopExpression danej jednostki.Creates a LoopExpression with the given body.

MakeBinary(ExpressionType, Expression, Expression) MakeBinary(ExpressionType, Expression, Expression) MakeBinary(ExpressionType, Expression, Expression) MakeBinary(ExpressionType, Expression, Expression)

Tworzy BinaryExpression, podane lewy i prawy operandów za pomocą wywołania metody odpowiedniej fabryki.Creates a BinaryExpression, given the left and right operands, by calling an appropriate factory method.

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

Tworzy BinaryExpressionpodany argument po lewej stronie, kliknij prawym przyciskiem myszy operand i implementacja metody, przez wywołanie metody odpowiedniej fabryki.Creates a BinaryExpression, given the left operand, right operand and implementing method, by calling the appropriate factory method.

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

Tworzy BinaryExpressionpodany argument po lewej stronie, kliknij prawym przyciskiem myszy operand, implementacja metody i — typ funkcji konwersji, przez wywołanie metody odpowiedniej fabryki.Creates a BinaryExpression, given the left operand, right operand, implementing method and type conversion function, by calling the appropriate factory method.

MakeCatchBlock(Type, ParameterExpression, Expression, Expression) MakeCatchBlock(Type, ParameterExpression, Expression, Expression) MakeCatchBlock(Type, ParameterExpression, Expression, Expression) MakeCatchBlock(Type, ParameterExpression, Expression, Expression)

Tworzy CatchBlock reprezentujący instrukcja catch, przy użyciu określonych elementów.Creates a CatchBlock representing a catch statement with the specified elements.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder i jeden argument.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and one argument.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder i dwa argumenty.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and two arguments.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder i trzy argumenty.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and three arguments.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder i cztery argumenty.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder and four arguments.

MakeDynamic(Type, CallSiteBinder, Expression[]) MakeDynamic(Type, CallSiteBinder, Expression[]) MakeDynamic(Type, CallSiteBinder, Expression[]) MakeDynamic(Type, CallSiteBinder, Expression[])

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

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

Tworzy DynamicExpression reprezentujący operację dynamiczną przez podany CallSiteBinder.Creates a DynamicExpression that represents a dynamic operation bound by the provided CallSiteBinder.

MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type) MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type) MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type) MakeGoto(GotoExpressionKind, LabelTarget, Expression, Type)

Tworzy GotoExpression reprezentujący przeskoku określonego GotoExpressionKind.Creates a GotoExpression representing a jump of the specified GotoExpressionKind. Wartość przekazana do etykiety po przeskakiwanie można również określić.The value passed to the label upon jumping can also be specified.

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

Tworzy IndexExpression reprezentująca dostęp do właściwości indeksowanych w obiekcie.Creates an IndexExpression that represents accessing an indexed property in an object.

MakeMemberAccess(Expression, MemberInfo) MakeMemberAccess(Expression, MemberInfo) MakeMemberAccess(Expression, MemberInfo) MakeMemberAccess(Expression, MemberInfo)

Tworzy MemberExpression reprezentująca dostęp do pola lub właściwości.Creates a MemberExpression that represents accessing either a field or a property.

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

Tworzy TryExpression reprezentujący bloku try z określonych elementów.Creates a TryExpression representing a try block with the specified elements.

MakeUnary(ExpressionType, Expression, Type) MakeUnary(ExpressionType, Expression, Type) MakeUnary(ExpressionType, Expression, Type) MakeUnary(ExpressionType, Expression, Type)

Tworzy UnaryExpression, podany argument operacji, przez wywołanie metody odpowiedniej fabryki.Creates a UnaryExpression, given an operand, by calling the appropriate factory method.

MakeUnary(ExpressionType, Expression, Type, MethodInfo) MakeUnary(ExpressionType, Expression, Type, MethodInfo) MakeUnary(ExpressionType, Expression, Type, MethodInfo) MakeUnary(ExpressionType, Expression, Type, MethodInfo)

Tworzy UnaryExpression, podany argument i implementacja metody, przez wywołanie metody odpowiedniej fabryki.Creates a UnaryExpression, given an operand and implementing method, by calling the appropriate factory method.

MemberBind(MemberInfo, IEnumerable<MemberBinding>) MemberBind(MemberInfo, IEnumerable<MemberBinding>) MemberBind(MemberInfo, IEnumerable<MemberBinding>) MemberBind(MemberInfo, IEnumerable<MemberBinding>)

Tworzy MemberMemberBinding reprezentujący cykliczne inicjowanie elementów członkowskich pola lub właściwości.Creates a MemberMemberBinding that represents the recursive initialization of members of a field or property.

MemberBind(MemberInfo, MemberBinding[]) MemberBind(MemberInfo, MemberBinding[]) MemberBind(MemberInfo, MemberBinding[]) MemberBind(MemberInfo, MemberBinding[])

Tworzy MemberMemberBinding reprezentujący cykliczne inicjowanie elementów członkowskich pola lub właściwości.Creates a MemberMemberBinding that represents the recursive initialization of members of a field or property.

MemberBind(MethodInfo, IEnumerable<MemberBinding>) MemberBind(MethodInfo, IEnumerable<MemberBinding>) MemberBind(MethodInfo, IEnumerable<MemberBinding>) MemberBind(MethodInfo, IEnumerable<MemberBinding>)

Tworzy MemberMemberBinding reprezentujący inicjowania cyklicznego elementów członkowskich elementu członkowskiego, która jest dostępna za pomocą metody dostępu właściwości.Creates a MemberMemberBinding that represents the recursive initialization of members of a member that is accessed by using a property accessor method.

MemberBind(MethodInfo, MemberBinding[]) MemberBind(MethodInfo, MemberBinding[]) MemberBind(MethodInfo, MemberBinding[]) MemberBind(MethodInfo, MemberBinding[])

Tworzy MemberMemberBinding reprezentujący inicjowania cyklicznego elementów członkowskich elementu członkowskiego, która jest dostępna za pomocą metody dostępu właściwości.Creates a MemberMemberBinding that represents the recursive initialization of members of a member that is accessed by using a property accessor method.

MemberInit(NewExpression, IEnumerable<MemberBinding>) MemberInit(NewExpression, IEnumerable<MemberBinding>) MemberInit(NewExpression, IEnumerable<MemberBinding>) MemberInit(NewExpression, IEnumerable<MemberBinding>)

Reprezentuje wyrażenie, które tworzy nowy obiekt i inicjuje właściwość obiektu.Represents an expression that creates a new object and initializes a property of the object.

MemberInit(NewExpression, MemberBinding[]) MemberInit(NewExpression, MemberBinding[]) MemberInit(NewExpression, MemberBinding[]) MemberInit(NewExpression, MemberBinding[])

Tworzy MemberInitExpression.Creates a MemberInitExpression.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Tworzy płytką kopię bieżącego Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Modulo(Expression, Expression) Modulo(Expression, Expression) Modulo(Expression, Expression) Modulo(Expression, Expression)

Tworzy BinaryExpression reprezentujący operacji arytmetycznych resztę.Creates a BinaryExpression that represents an arithmetic remainder operation.

Modulo(Expression, Expression, MethodInfo) Modulo(Expression, Expression, MethodInfo) Modulo(Expression, Expression, MethodInfo) Modulo(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operacji arytmetycznych resztę.Creates a BinaryExpression that represents an arithmetic remainder operation.

ModuloAssign(Expression, Expression) ModuloAssign(Expression, Expression) ModuloAssign(Expression, Expression) ModuloAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację przypisania resztę.Creates a BinaryExpression that represents a remainder assignment operation.

ModuloAssign(Expression, Expression, MethodInfo) ModuloAssign(Expression, Expression, MethodInfo) ModuloAssign(Expression, Expression, MethodInfo) ModuloAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację przypisania resztę.Creates a BinaryExpression that represents a remainder assignment operation.

ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression) ModuloAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację przypisania resztę.Creates a BinaryExpression that represents a remainder assignment operation.

Multiply(Expression, Expression) Multiply(Expression, Expression) Multiply(Expression, Expression) Multiply(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację arytmetyczną mnożenia, która nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic multiplication operation that does not have overflow checking.

Multiply(Expression, Expression, MethodInfo) Multiply(Expression, Expression, MethodInfo) Multiply(Expression, Expression, MethodInfo) Multiply(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację arytmetyczną mnożenia, która nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic multiplication operation that does not have overflow checking.

MultiplyAssign(Expression, Expression) MultiplyAssign(Expression, Expression) MultiplyAssign(Expression, Expression) MultiplyAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację przypisania mnożenia, która nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking.

MultiplyAssign(Expression, Expression, MethodInfo) MultiplyAssign(Expression, Expression, MethodInfo) MultiplyAssign(Expression, Expression, MethodInfo) MultiplyAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację przypisania mnożenia, która nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking.

MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację przypisania mnożenia, która nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a multiplication assignment operation that does not have overflow checking.

MultiplyAssignChecked(Expression, Expression) MultiplyAssignChecked(Expression, Expression) MultiplyAssignChecked(Expression, Expression) MultiplyAssignChecked(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację przypisania mnożenia, która ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking.

MultiplyAssignChecked(Expression, Expression, MethodInfo) MultiplyAssignChecked(Expression, Expression, MethodInfo) MultiplyAssignChecked(Expression, Expression, MethodInfo) MultiplyAssignChecked(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację przypisania mnożenia, która ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking.

MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) MultiplyAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację przypisania mnożenia, która ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a multiplication assignment operation that has overflow checking.

MultiplyChecked(Expression, Expression) MultiplyChecked(Expression, Expression) MultiplyChecked(Expression, Expression) MultiplyChecked(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację arytmetyczną mnożenia, która ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic multiplication operation that has overflow checking.

MultiplyChecked(Expression, Expression, MethodInfo) MultiplyChecked(Expression, Expression, MethodInfo) MultiplyChecked(Expression, Expression, MethodInfo) MultiplyChecked(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację arytmetyczną mnożenia, która ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic multiplication operation that has overflow checking.

Negate(Expression) Negate(Expression) Negate(Expression) Negate(Expression)

Tworzy UnaryExpression reprezentujący operację arytmetyczny negacji.Creates a UnaryExpression that represents an arithmetic negation operation.

Negate(Expression, MethodInfo) Negate(Expression, MethodInfo) Negate(Expression, MethodInfo) Negate(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący operację arytmetyczny negacji.Creates a UnaryExpression that represents an arithmetic negation operation.

NegateChecked(Expression) NegateChecked(Expression) NegateChecked(Expression) NegateChecked(Expression)

Tworzy UnaryExpression reprezentujący operację arytmetyczny negacji, który ma sprawdzanie przepełnienia.Creates a UnaryExpression that represents an arithmetic negation operation that has overflow checking.

NegateChecked(Expression, MethodInfo) NegateChecked(Expression, MethodInfo) NegateChecked(Expression, MethodInfo) NegateChecked(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący operację arytmetyczny negacji, który ma sprawdzanie przepełnienia.Creates a UnaryExpression that represents an arithmetic negation operation that has overflow checking. Implementowanie metoda może być określona.The implementing method can be specified.

New(ConstructorInfo) New(ConstructorInfo) New(ConstructorInfo) New(ConstructorInfo)

Tworzy NewExpression reprezentujący wywołanie określonego konstruktora, który nie przyjmuje żadnych argumentów.Creates a NewExpression that represents calling the specified constructor that takes no arguments.

New(ConstructorInfo, Expression[]) New(ConstructorInfo, Expression[]) New(ConstructorInfo, Expression[]) New(ConstructorInfo, Expression[])

Tworzy NewExpression reprezentujący wywołanie konstruktora określonego z określonymi argumentami.Creates a NewExpression that represents calling the specified constructor with the specified arguments.

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

Tworzy NewExpression reprezentujący wywołanie konstruktora określonego z określonymi argumentami.Creates a NewExpression that represents calling the specified constructor with the specified arguments.

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

Tworzy NewExpression reprezentujący wywołanie konstruktora określonego z określonymi argumentami.Creates a NewExpression that represents calling the specified constructor with the specified arguments. Elementy członkowskie, które uzyskują dostęp do pól Konstruktor inicjowane są określone.The members that access the constructor initialized fields are specified.

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

Tworzy NewExpression reprezentujący wywołanie konstruktora określonego z określonymi argumentami.Creates a NewExpression that represents calling the specified constructor with the specified arguments. Elementy członkowskie, które uzyskują dostęp do pól Konstruktor inicjowane są określane jako tablica.The members that access the constructor initialized fields are specified as an array.

New(Type) New(Type) New(Type) New(Type)

Tworzy NewExpression reprezentujący wywołanie konstruktora bez parametrów dla określonego typu.Creates a NewExpression that represents calling the parameterless constructor of the specified type.

NewArrayBounds(Type, Expression[]) NewArrayBounds(Type, Expression[]) NewArrayBounds(Type, Expression[]) NewArrayBounds(Type, Expression[])

Tworzy NewArrayExpression reprezentujący tworzenie tablicy, który ma określony stopień.Creates a NewArrayExpression that represents creating an array that has a specified rank.

NewArrayBounds(Type, IEnumerable<Expression>) NewArrayBounds(Type, IEnumerable<Expression>) NewArrayBounds(Type, IEnumerable<Expression>) NewArrayBounds(Type, IEnumerable<Expression>)

Tworzy NewArrayExpression reprezentujący tworzenie tablicy, który ma określony stopień.Creates a NewArrayExpression that represents creating an array that has a specified rank.

NewArrayInit(Type, Expression[]) NewArrayInit(Type, Expression[]) NewArrayInit(Type, Expression[]) NewArrayInit(Type, Expression[])

Tworzy NewArrayExpression reprezentująca tablicę jednowymiarową tworzenia i inicjując go z listy elementów.Creates a NewArrayExpression that represents creating a one-dimensional array and initializing it from a list of elements.

NewArrayInit(Type, IEnumerable<Expression>) NewArrayInit(Type, IEnumerable<Expression>) NewArrayInit(Type, IEnumerable<Expression>) NewArrayInit(Type, IEnumerable<Expression>)

Tworzy NewArrayExpression reprezentująca tablicę jednowymiarową tworzenia i inicjując go z listy elementów.Creates a NewArrayExpression that represents creating a one-dimensional array and initializing it from a list of elements.

Not(Expression) Not(Expression) Not(Expression) Not(Expression)

Tworzy UnaryExpression reprezentujący operację dopełnienia bitowego.Creates a UnaryExpression that represents a bitwise complement operation.

Not(Expression, MethodInfo) Not(Expression, MethodInfo) Not(Expression, MethodInfo) Not(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący operację dopełnienia bitowego.Creates a UnaryExpression that represents a bitwise complement operation. Implementowanie metoda może być określona.The implementing method can be specified.

NotEqual(Expression, Expression) NotEqual(Expression, Expression) NotEqual(Expression, Expression) NotEqual(Expression, Expression)

Tworzy BinaryExpression reprezentujący porównania nierówności.Creates a BinaryExpression that represents an inequality comparison.

NotEqual(Expression, Expression, Boolean, MethodInfo) NotEqual(Expression, Expression, Boolean, MethodInfo) NotEqual(Expression, Expression, Boolean, MethodInfo) NotEqual(Expression, Expression, Boolean, MethodInfo)

Tworzy BinaryExpression reprezentujący porównania nierówności.Creates a BinaryExpression that represents an inequality comparison.

OnesComplement(Expression) OnesComplement(Expression) OnesComplement(Expression) OnesComplement(Expression)

Zwraca wyrażenie odpowiadające te dopełnienia.Returns the expression representing the ones complement.

OnesComplement(Expression, MethodInfo) OnesComplement(Expression, MethodInfo) OnesComplement(Expression, MethodInfo) OnesComplement(Expression, MethodInfo)

Zwraca wyrażenie odpowiadające te dopełnienia.Returns the expression representing the ones complement.

Or(Expression, Expression) Or(Expression, Expression) Or(Expression, Expression) Or(Expression, Expression)

Tworzy BinaryExpression reprezentujący bitowej OR operacji.Creates a BinaryExpression that represents a bitwise OR operation.

Or(Expression, Expression, MethodInfo) Or(Expression, Expression, MethodInfo) Or(Expression, Expression, MethodInfo) Or(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący bitowej OR operacji.Creates a BinaryExpression that represents a bitwise OR operation.

OrAssign(Expression, Expression) OrAssign(Expression, Expression) OrAssign(Expression, Expression) OrAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący bitowe operacji przypisania OR.Creates a BinaryExpression that represents a bitwise OR assignment operation.

OrAssign(Expression, Expression, MethodInfo) OrAssign(Expression, Expression, MethodInfo) OrAssign(Expression, Expression, MethodInfo) OrAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący bitowe operacji przypisania OR.Creates a BinaryExpression that represents a bitwise OR assignment operation.

OrAssign(Expression, Expression, MethodInfo, LambdaExpression) OrAssign(Expression, Expression, MethodInfo, LambdaExpression) OrAssign(Expression, Expression, MethodInfo, LambdaExpression) OrAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący bitowe operacji przypisania OR.Creates a BinaryExpression that represents a bitwise OR assignment operation.

OrElse(Expression, Expression) OrElse(Expression, Expression) OrElse(Expression, Expression) OrElse(Expression, Expression)

Tworzy BinaryExpression reprezentujący warunkowe OR operacji, która ocenia drugi argument operacji tylko wtedy, gdy pierwszy operand ma wartość false.Creates a BinaryExpression that represents a conditional OR operation that evaluates the second operand only if the first operand evaluates to false.

OrElse(Expression, Expression, MethodInfo) OrElse(Expression, Expression, MethodInfo) OrElse(Expression, Expression, MethodInfo) OrElse(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący warunkowe OR operacji, która ocenia drugi argument operacji tylko wtedy, gdy pierwszy operand ma wartość false.Creates a BinaryExpression that represents a conditional OR operation that evaluates the second operand only if the first operand evaluates to false.

Parameter(Type) Parameter(Type) Parameter(Type) Parameter(Type)

Tworzy ParameterExpression węzeł, który może służyć do identyfikowania parametr lub zmienna w drzewo wyrażenia.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

Parameter(Type, String) Parameter(Type, String) Parameter(Type, String) Parameter(Type, String)

Tworzy ParameterExpression węzeł, który może służyć do identyfikowania parametr lub zmienna w drzewo wyrażenia.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

PostDecrementAssign(Expression) PostDecrementAssign(Expression) PostDecrementAssign(Expression) PostDecrementAssign(Expression)

Tworzy UnaryExpression reprezentujący przypisanie wyrażenia, a następnie przez kolejne dekrementacji 1 oryginalne wyrażenie.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression.

PostDecrementAssign(Expression, MethodInfo) PostDecrementAssign(Expression, MethodInfo) PostDecrementAssign(Expression, MethodInfo) PostDecrementAssign(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący przypisanie wyrażenia, a następnie przez kolejne dekrementacji 1 oryginalne wyrażenie.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression.

PostIncrementAssign(Expression) PostIncrementAssign(Expression) PostIncrementAssign(Expression) PostIncrementAssign(Expression)

Tworzy UnaryExpression reprezentujący przypisanie wyrażenia, a następnie przez kolejne przyrostu 1 oryginalne wyrażenie.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression.

PostIncrementAssign(Expression, MethodInfo) PostIncrementAssign(Expression, MethodInfo) PostIncrementAssign(Expression, MethodInfo) PostIncrementAssign(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący przypisanie wyrażenia, a następnie przez kolejne przyrostu 1 oryginalne wyrażenie.Creates a UnaryExpression that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression.

Power(Expression, Expression) Power(Expression, Expression) Power(Expression, Expression) Power(Expression, Expression)

Tworzy BinaryExpression reprezentujący zwiększenie liczby do potęgi.Creates a BinaryExpression that represents raising a number to a power.

Power(Expression, Expression, MethodInfo) Power(Expression, Expression, MethodInfo) Power(Expression, Expression, MethodInfo) Power(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący zwiększenie liczby do potęgi.Creates a BinaryExpression that represents raising a number to a power.

PowerAssign(Expression, Expression) PowerAssign(Expression, Expression) PowerAssign(Expression, Expression) PowerAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący podnoszenia wyrażenia do potęgi i przypisywanie wynik wyrażenia.Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression.

PowerAssign(Expression, Expression, MethodInfo) PowerAssign(Expression, Expression, MethodInfo) PowerAssign(Expression, Expression, MethodInfo) PowerAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący podnoszenia wyrażenia do potęgi i przypisywanie wynik wyrażenia.Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression.

PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) PowerAssign(Expression, Expression, MethodInfo, LambdaExpression) PowerAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący podnoszenia wyrażenia do potęgi i przypisywanie wynik wyrażenia.Creates a BinaryExpression that represents raising an expression to a power and assigning the result back to the expression.

PreDecrementAssign(Expression) PreDecrementAssign(Expression) PreDecrementAssign(Expression) PreDecrementAssign(Expression)

Tworzy UnaryExpression zmniejsza tego wyrażenia przez 1 i przypisuje wynik z powrotem do wyrażenia.Creates a UnaryExpression that decrements the expression by 1 and assigns the result back to the expression.

PreDecrementAssign(Expression, MethodInfo) PreDecrementAssign(Expression, MethodInfo) PreDecrementAssign(Expression, MethodInfo) PreDecrementAssign(Expression, MethodInfo)

Tworzy UnaryExpression zmniejsza tego wyrażenia przez 1 i przypisuje wynik z powrotem do wyrażenia.Creates a UnaryExpression that decrements the expression by 1 and assigns the result back to the expression.

PreIncrementAssign(Expression) PreIncrementAssign(Expression) PreIncrementAssign(Expression) PreIncrementAssign(Expression)

Tworzy UnaryExpression , zwiększa się o 1 wyrażenia i przypisuje wynik wyrażenia.Creates a UnaryExpression that increments the expression by 1 and assigns the result back to the expression.

PreIncrementAssign(Expression, MethodInfo) PreIncrementAssign(Expression, MethodInfo) PreIncrementAssign(Expression, MethodInfo) PreIncrementAssign(Expression, MethodInfo)

Tworzy UnaryExpression , zwiększa się o 1 wyrażenia i przypisuje wynik wyrażenia.Creates a UnaryExpression that increments the expression by 1 and assigns the result back to the expression.

Property(Expression, MethodInfo) Property(Expression, MethodInfo) Property(Expression, MethodInfo) Property(Expression, MethodInfo)

Tworzy MemberExpression reprezentująca dostęp do właściwości przy użyciu metody dostępu właściwości.Creates a MemberExpression that represents accessing a property by using a property accessor method.

Property(Expression, PropertyInfo) Property(Expression, PropertyInfo) Property(Expression, PropertyInfo) Property(Expression, PropertyInfo)

Tworzy MemberExpression reprezentująca dostęp do właściwości.Creates a MemberExpression that represents accessing a property.

Property(Expression, PropertyInfo, Expression[]) Property(Expression, PropertyInfo, Expression[]) Property(Expression, PropertyInfo, Expression[]) Property(Expression, PropertyInfo, Expression[])

Tworzy IndexExpression reprezentującą dostępu do właściwości indeksowanych.Creates an IndexExpression representing the access to an indexed property.

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

Tworzy IndexExpression reprezentującą dostępu do właściwości indeksowanych.Creates an IndexExpression representing the access to an indexed property.

Property(Expression, String) Property(Expression, String) Property(Expression, String) Property(Expression, String)

Tworzy MemberExpression reprezentująca dostęp do właściwości.Creates a MemberExpression that represents accessing a property.

Property(Expression, String, Expression[]) Property(Expression, String, Expression[]) Property(Expression, String, Expression[]) Property(Expression, String, Expression[])

Tworzy IndexExpression reprezentującą dostępu do właściwości indeksowanych.Creates an IndexExpression representing the access to an indexed property.

Property(Expression, Type, String) Property(Expression, Type, String) Property(Expression, Type, String) Property(Expression, Type, String)

Tworzy MemberExpression uzyskiwania dostępu do właściwości.Creates a MemberExpression accessing a property.

PropertyOrField(Expression, String) PropertyOrField(Expression, String) PropertyOrField(Expression, String) PropertyOrField(Expression, String)

Tworzy MemberExpression reprezentująca dostęp do właściwości lub pola.Creates a MemberExpression that represents accessing a property or field.

Quote(Expression) Quote(Expression) Quote(Expression) Quote(Expression)

Tworzy UnaryExpression reprezentujący wyrażenie stałej wartości typu Expression.Creates a UnaryExpression that represents an expression that has a constant value of type Expression.

Reduce() Reduce() Reduce() Reduce()

Zmniejsza tego węzła w celu prostszego wyrażenia.Reduces this node to a simpler expression. Jeśli CanReduce zwraca wartość true, powinny zostać zwrócone prawidłowe wyrażenie.If CanReduce returns true, this should return a valid expression. Ta metoda może zwrócić inny węzeł, która sama musi zostać obniżona.This method can return another node which itself must be reduced.

ReduceAndCheck() ReduceAndCheck() ReduceAndCheck() ReduceAndCheck()

Zmniejsza tego węzła w celu prostszego wyrażenia.Reduces this node to a simpler expression. Jeśli CanReduce zwraca wartość true, powinny zostać zwrócone prawidłowe wyrażenie.If CanReduce returns true, this should return a valid expression. Ta metoda może zwrócić inny węzeł, która sama musi zostać obniżona.This method can return another node which itself must be reduced.

ReduceExtensions() ReduceExtensions() ReduceExtensions() ReduceExtensions()

Zmniejsza wyrażenia na typ węzła znane, (który nie jest węzłem rozszerzenia) lub po prostu zwraca wyrażenie, jeśli nie jest jeszcze znany typ.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.

ReferenceEqual(Expression, Expression) ReferenceEqual(Expression, Expression) ReferenceEqual(Expression, Expression) ReferenceEqual(Expression, Expression)

Tworzy BinaryExpression reprezentujący porównanie równości odwołań.Creates a BinaryExpression that represents a reference equality comparison.

ReferenceNotEqual(Expression, Expression) ReferenceNotEqual(Expression, Expression) ReferenceNotEqual(Expression, Expression) ReferenceNotEqual(Expression, Expression)

Tworzy BinaryExpression reprezentujący porównanie nierówności odwołań.Creates a BinaryExpression that represents a reference inequality comparison.

Rethrow() Rethrow() Rethrow() Rethrow()

Tworzy UnaryExpression reprezentujący ponowne generowanie wyjątku.Creates a UnaryExpression that represents a rethrowing of an exception.

Rethrow(Type) Rethrow(Type) Rethrow(Type) Rethrow(Type)

Tworzy UnaryExpression reprezentujący ponowne generowanie wyjątku z danym typem.Creates a UnaryExpression that represents a rethrowing of an exception with a given type.

Return(LabelTarget) Return(LabelTarget) Return(LabelTarget) Return(LabelTarget)

Tworzy GotoExpression reprezentujący instrukcji return.Creates a GotoExpression representing a return statement.

Return(LabelTarget, Expression) Return(LabelTarget, Expression) Return(LabelTarget, Expression) Return(LabelTarget, Expression)

Tworzy GotoExpression reprezentujący instrukcji return.Creates a GotoExpression representing a return statement. Można określić wartość przekazana do etykiety na skok.The value passed to the label upon jumping can be specified.

Return(LabelTarget, Expression, Type) Return(LabelTarget, Expression, Type) Return(LabelTarget, Expression, Type) Return(LabelTarget, Expression, Type)

Tworzy GotoExpression reprezentujący instrukcję return z określonym typem.Creates a GotoExpression representing a return statement with the specified type. Można określić wartość przekazana do etykiety na skok.The value passed to the label upon jumping can be specified.

Return(LabelTarget, Type) Return(LabelTarget, Type) Return(LabelTarget, Type) Return(LabelTarget, Type)

Tworzy GotoExpression reprezentujący instrukcję return z określonym typem.Creates a GotoExpression representing a return statement with the specified type.

RightShift(Expression, Expression) RightShift(Expression, Expression) RightShift(Expression, Expression) RightShift(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację bitowego przesunięcia w prawo.Creates a BinaryExpression that represents a bitwise right-shift operation.

RightShift(Expression, Expression, MethodInfo) RightShift(Expression, Expression, MethodInfo) RightShift(Expression, Expression, MethodInfo) RightShift(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację bitowego przesunięcia w prawo.Creates a BinaryExpression that represents a bitwise right-shift operation.

RightShiftAssign(Expression, Expression) RightShiftAssign(Expression, Expression) RightShiftAssign(Expression, Expression) RightShiftAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację logiczną przypisania przesunięcia w prawo.Creates a BinaryExpression that represents a bitwise right-shift assignment operation.

RightShiftAssign(Expression, Expression, MethodInfo) RightShiftAssign(Expression, Expression, MethodInfo) RightShiftAssign(Expression, Expression, MethodInfo) RightShiftAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację logiczną przypisania przesunięcia w prawo.Creates a BinaryExpression that represents a bitwise right-shift assignment operation.

RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression) RightShiftAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację logiczną przypisania przesunięcia w prawo.Creates a BinaryExpression that represents a bitwise right-shift assignment operation.

RuntimeVariables(IEnumerable<ParameterExpression>) RuntimeVariables(IEnumerable<ParameterExpression>) RuntimeVariables(IEnumerable<ParameterExpression>) RuntimeVariables(IEnumerable<ParameterExpression>)

Tworzy wystąpienie RuntimeVariablesExpression.Creates an instance of RuntimeVariablesExpression.

RuntimeVariables(ParameterExpression[]) RuntimeVariables(ParameterExpression[]) RuntimeVariables(ParameterExpression[]) RuntimeVariables(ParameterExpression[])

Tworzy wystąpienie RuntimeVariablesExpression.Creates an instance of RuntimeVariablesExpression.

Subtract(Expression, Expression) Subtract(Expression, Expression) Subtract(Expression, Expression) Subtract(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację odejmowania arytmetyczne, które ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic subtraction operation that does not have overflow checking.

Subtract(Expression, Expression, MethodInfo) Subtract(Expression, Expression, MethodInfo) Subtract(Expression, Expression, MethodInfo) Subtract(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację odejmowania arytmetyczne, które ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic subtraction operation that does not have overflow checking.

SubtractAssign(Expression, Expression) SubtractAssign(Expression, Expression) SubtractAssign(Expression, Expression) SubtractAssign(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację Przypisanie odejmowania, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking.

SubtractAssign(Expression, Expression, MethodInfo) SubtractAssign(Expression, Expression, MethodInfo) SubtractAssign(Expression, Expression, MethodInfo) SubtractAssign(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację Przypisanie odejmowania, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking.

SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssign(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację Przypisanie odejmowania, który nie ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a subtraction assignment operation that does not have overflow checking.

SubtractAssignChecked(Expression, Expression) SubtractAssignChecked(Expression, Expression) SubtractAssignChecked(Expression, Expression) SubtractAssignChecked(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację Przypisanie odejmowania, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking.

SubtractAssignChecked(Expression, Expression, MethodInfo) SubtractAssignChecked(Expression, Expression, MethodInfo) SubtractAssignChecked(Expression, Expression, MethodInfo) SubtractAssignChecked(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację Przypisanie odejmowania, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking.

SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression) SubtractAssignChecked(Expression, Expression, MethodInfo, LambdaExpression)

Tworzy BinaryExpression reprezentujący operację Przypisanie odejmowania, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents a subtraction assignment operation that has overflow checking.

SubtractChecked(Expression, Expression) SubtractChecked(Expression, Expression) SubtractChecked(Expression, Expression) SubtractChecked(Expression, Expression)

Tworzy BinaryExpression reprezentujący operację odejmowania arytmetyczne, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic subtraction operation that has overflow checking.

SubtractChecked(Expression, Expression, MethodInfo) SubtractChecked(Expression, Expression, MethodInfo) SubtractChecked(Expression, Expression, MethodInfo) SubtractChecked(Expression, Expression, MethodInfo)

Tworzy BinaryExpression reprezentujący operację odejmowania arytmetyczne, który ma sprawdzanie przepełnienia.Creates a BinaryExpression that represents an arithmetic subtraction operation that has overflow checking.

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

Tworzy SwitchExpression reprezentujący switch instrukcję, która ma przypadek domyślny.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Tworzy SwitchExpression reprezentujący switch instrukcję, która ma przypadek domyślny.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Tworzy SwitchExpression reprezentujący switch instrukcję, która ma przypadek domyślny.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Tworzy SwitchExpression reprezentujący switch instrukcję bez przypadek domyślny.Creates a SwitchExpression that represents a switch statement without a default case.

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

Tworzy SwitchExpression reprezentujący switch instrukcję, która ma przypadek domyślny.Creates a SwitchExpression that represents a switch statement that has a default case.

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

Tworzy SwitchExpression reprezentujący switch instrukcję, która ma przypadek domyślny.Creates a SwitchExpression that represents a switch statement that has a default case.

SwitchCase(Expression, Expression[]) SwitchCase(Expression, Expression[]) SwitchCase(Expression, Expression[]) SwitchCase(Expression, Expression[])

Tworzy SwitchCase do użycia w SwitchExpression.Creates a SwitchCase for use in a SwitchExpression.

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

Tworzy SwitchCase obiektów, które zostaną użyte w SwitchExpression obiektu.Creates a SwitchCase object to be used in a SwitchExpression object.

SymbolDocument(String) SymbolDocument(String) SymbolDocument(String) SymbolDocument(String)

Tworzy wystąpienie SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

SymbolDocument(String, Guid) SymbolDocument(String, Guid) SymbolDocument(String, Guid) SymbolDocument(String, Guid)

Tworzy wystąpienie SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

SymbolDocument(String, Guid, Guid) SymbolDocument(String, Guid, Guid) SymbolDocument(String, Guid, Guid) SymbolDocument(String, Guid, Guid)

Tworzy wystąpienie SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

SymbolDocument(String, Guid, Guid, Guid) SymbolDocument(String, Guid, Guid, Guid) SymbolDocument(String, Guid, Guid, Guid) SymbolDocument(String, Guid, Guid, Guid)

Tworzy wystąpienie SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

Throw(Expression) Throw(Expression) Throw(Expression) Throw(Expression)

Tworzy UnaryExpression reprezentujący, zostanie zgłoszony wyjątek.Creates a UnaryExpression that represents a throwing of an exception.

Throw(Expression, Type) Throw(Expression, Type) Throw(Expression, Type) Throw(Expression, Type)

Tworzy UnaryExpression reprezentujący, zostanie zgłoszony wyjątek z danym typem.Creates a UnaryExpression that represents a throwing of an exception with a given type.

ToString() ToString() ToString() ToString()

Zwraca tekstową reprezentację wartości Expression.Returns a textual representation of the Expression.

TryCatch(Expression, CatchBlock[]) TryCatch(Expression, CatchBlock[]) TryCatch(Expression, CatchBlock[]) TryCatch(Expression, CatchBlock[])

Tworzy TryExpression reprezentujący bloku try z dowolnej liczby catch, instrukcje i ani błędów, ani bloku finally.Creates a TryExpression representing a try block with any number of catch statements and neither a fault nor finally block.

TryCatchFinally(Expression, Expression, CatchBlock[]) TryCatchFinally(Expression, Expression, CatchBlock[]) TryCatchFinally(Expression, Expression, CatchBlock[]) TryCatchFinally(Expression, Expression, CatchBlock[])

Tworzy TryExpression reprezentujący bloku try z dowolnej liczby instrukcji catch i bloku finally.Creates a TryExpression representing a try block with any number of catch statements and a finally block.

TryFault(Expression, Expression) TryFault(Expression, Expression) TryFault(Expression, Expression) TryFault(Expression, Expression)

Tworzy TryExpression reprezentujący bloku try z blokiem błędów i nie catch, instrukcje.Creates a TryExpression representing a try block with a fault block and no catch statements.

TryFinally(Expression, Expression) TryFinally(Expression, Expression) TryFinally(Expression, Expression) TryFinally(Expression, Expression)

Tworzy TryExpression reprezentujący za pomocą bloku try finally blok i nie catch, instrukcje.Creates a TryExpression representing a try block with a finally block and no catch statements.

TryGetActionType(Type[], Type) TryGetActionType(Type[], Type) TryGetActionType(Type[], Type) TryGetActionType(Type[], Type)

Tworzy Type obiekt, który reprezentuje typ ogólny delegat elementu System.Action, który zawiera argumenty określonego typu.Creates a Type object that represents a generic System.Action delegate type that has specific type arguments.

TryGetFuncType(Type[], Type) TryGetFuncType(Type[], Type) TryGetFuncType(Type[], Type) TryGetFuncType(Type[], Type)

Tworzy Type obiekt, który reprezentuje typ ogólny delegata System.Func, który zawiera argumenty określonego typu.Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. Ostatni argument typu określa zwracany typ delegata utworzony.The last type argument specifies the return type of the created delegate.

TypeAs(Expression, Type) TypeAs(Expression, Type) TypeAs(Expression, Type) TypeAs(Expression, Type)

Tworzy UnaryExpression reprezentujący jawnego odwołania lub konwersja boxing gdzie null jest podany, jeśli konwersja nie powiedzie się.Creates a UnaryExpression that represents an explicit reference or boxing conversion where null is supplied if the conversion fails.

TypeEqual(Expression, Type) TypeEqual(Expression, Type) TypeEqual(Expression, Type) TypeEqual(Expression, Type)

Tworzy TypeBinaryExpression , porównuje tożsamości typu run-time.Creates a TypeBinaryExpression that compares run-time type identity.

TypeIs(Expression, Type) TypeIs(Expression, Type) TypeIs(Expression, Type) TypeIs(Expression, Type)

Tworzy TypeBinaryExpression.Creates a TypeBinaryExpression.

UnaryPlus(Expression) UnaryPlus(Expression) UnaryPlus(Expression) UnaryPlus(Expression)

Tworzy UnaryExpression reprezentujący Jednoargumentowa operacja plus.Creates a UnaryExpression that represents a unary plus operation.

UnaryPlus(Expression, MethodInfo) UnaryPlus(Expression, MethodInfo) UnaryPlus(Expression, MethodInfo) UnaryPlus(Expression, MethodInfo)

Tworzy UnaryExpression reprezentujący Jednoargumentowa operacja plus.Creates a UnaryExpression that represents a unary plus operation.

Unbox(Expression, Type) Unbox(Expression, Type) Unbox(Expression, Type) Unbox(Expression, Type)

Tworzy UnaryExpression reprezentujący jawne rozpakowywania.Creates a UnaryExpression that represents an explicit unboxing.

Variable(Type) Variable(Type) Variable(Type) Variable(Type)

Tworzy ParameterExpression węzeł, który może służyć do identyfikowania parametr lub zmienna w drzewo wyrażenia.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

Variable(Type, String) Variable(Type, String) Variable(Type, String) Variable(Type, String)

Tworzy ParameterExpression węzeł, który może służyć do identyfikowania parametr lub zmienna w drzewo wyrażenia.Creates a ParameterExpression node that can be used to identify a parameter or a variable in an expression tree.

VisitChildren(ExpressionVisitor) VisitChildren(ExpressionVisitor) VisitChildren(ExpressionVisitor) VisitChildren(ExpressionVisitor)

Zmniejsza węzeł, a następnie wywołuje delegata gości na mniejsze wyrażenia.Reduces the node and then calls the visitor delegate on the reduced expression. Metoda zgłasza wyjątek, jeśli węzeł nie jest obniżaniu.The method throws an exception if the node is not reducible.

Dotyczy