Expression Expression Expression Expression Class

Definizione

Fornisce la classe di base dalla quale derivano le classi che rappresentano i nodi della struttura ad albero delle espressioni.Provides the base class from which the classes that represent expression tree nodes are derived. Contiene anche metodi factory static (Shared in Visual Basic) per creare i vari di tipi di nodo.It also contains static (Shared in Visual Basic) factory methods to create the various node types. Si tratta di una classe abstract.This is an abstract class.

public ref class Expression abstract
public abstract class Expression
type Expression = class
Public MustInherit Class Expression
Ereditarietà
ExpressionExpressionExpressionExpression
Derivato

Esempi

Nell'esempio di codice seguente viene illustrato come creare un'espressione di blocco.The following code example shows how to create a block expression. L'espressione di blocco è costituita da MethodCallExpression due ConstantExpression oggetti e un oggetto.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

Costruttori

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

Costruisce una nuova istanza di Expression.Constructs a new instance of Expression.

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

Inizializza una nuova istanza della classe Expression.Initializes a new instance of the Expression class.

Proprietà

CanReduce CanReduce CanReduce CanReduce

Indica che il nodo può essere ridotto a un nodo più semplice.Indicates that the node can be reduced to a simpler node. Se restituisce true, è possibile chiamare Reduce() per generare la forma ridotta.If this returns true, Reduce() can be called to produce the reduced form.

NodeType NodeType NodeType NodeType

Ottiene il tipo di nodo di Expression.Gets the node type of this Expression.

Type Type Type Type

Ottiene il tipo statico dell'espressione rappresentata da Expression.Gets the static type of the expression that this Expression represents.

Metodi

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

Invia al metodo Visit specifico per questo tipo di nodo.Dispatches to the specific visit method for this node type. Ad esempio, MethodCallExpression chiama VisitMethodCall(MethodCallExpression).For example, MethodCallExpression calls the VisitMethodCall(MethodCallExpression).

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di addizione aritmetica che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di addizione aritmetica che non ha il controllo dell'overflow.Creates a BinaryExpression that represents an arithmetic addition operation that does not have overflow checking. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di addizione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di addizione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di addizione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di addizione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di addizione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di addizione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di addizione aritmetica che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di addizione aritmetica che ha il controllo dell'overflow.Creates a BinaryExpression that represents an arithmetic addition operation that has overflow checking. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione AND bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione AND bit per bit.Creates a BinaryExpression that represents a bitwise AND operation. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione AND condizionale che valuta il secondo operando solo se il primo operando restituisce 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)

Crea un oggetto BinaryExpression che rappresenta un'operazione AND condizionale che valuta il secondo operando solo se il primo operando viene risolto in true.Creates a BinaryExpression that represents a conditional AND operation that evaluates the second operand only if the first operand is resolved to true. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione AND bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione AND bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione AND bit per bit.Creates a BinaryExpression that represents a bitwise AND assignment operation.

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

Crea un oggetto IndexExpression per accedere a una matrice.Creates an IndexExpression to access an array.

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

Crea un oggetto IndexExpression per accedere a una matrice multidimensionale.Creates an IndexExpression to access a multidimensional array.

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

Crea un oggetto BinaryExpression che rappresenta l'applicazione di un operatore di indice di matrice a una matrice con numero di dimensioni pari a 1.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[])

Crea un oggetto MethodCallExpression che rappresenta l'applicazione di un operatore di indice di matrice a una matrice multidimensionale.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>)

Crea un oggetto MethodCallExpressionche rappresenta l'applicazione di un operatore di indice di matrice a una matrice con numero di dimensioni maggiore di 1.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)

Crea un oggetto UnaryExpression che rappresenta un'espressione per ottenere la lunghezza di una matrice unidimensionale.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione.Creates a BinaryExpression that represents an assignment operation.

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

Crea un oggetto MemberAssignment che rappresenta l'inizializzazione di un campo o di una proprietà.Creates a MemberAssignment that represents the initialization of a field or property.

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

Crea un oggetto MemberAssignment che rappresenta l'inizializzazione di un membro usando un metodo della funzione di accesso alle proprietà.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)

Crea un oggetto BlockExpression che contiene due espressioni e non dispone di variabili.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)

Crea un oggetto BlockExpression che contiene tre espressioni e non dispone di variabili.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)

Crea un oggetto BlockExpression che contiene quattro espressioni e non dispone di variabili.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)

Crea un oggetto BlockExpression che contiene cinque espressioni e non dispone di variabili.Creates a BlockExpression that contains five expressions and has no variables.

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

Crea un oggetto BlockExpression che contiene le espressioni specificate e non ha variabili.Creates a BlockExpression that contains the given expressions and has no variables.

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

Crea un oggetto BlockExpression che contiene le espressioni specificate e non ha variabili.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[])

Crea un oggetto BlockExpression che contiene le espressioni e le variabili specificate.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>)

Crea un oggetto BlockExpression che contiene le espressioni e le variabili specificate.Creates a BlockExpression that contains the given variables and expressions.

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

Crea un oggetto BlockExpression che contiene le espressioni specificate, non dispone di variabili e dispone del tipo di risultato specifico.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>)

Crea un oggetto BlockExpression che contiene le espressioni specificate, non dispone di variabili e dispone del tipo di risultato specifico.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[])

Crea un oggetto BlockExpression che contiene le espressioni e le variabili specificate.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>)

Crea un oggetto BlockExpression che contiene le espressioni e le variabili specificate.Creates a BlockExpression that contains the given variables and expressions.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione break.Creates a GotoExpression representing a break statement.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione break.Creates a GotoExpression representing a break statement. Il valore passato all'etichetta al momento del passaggio può essere specificato.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)

Crea un oggetto GotoExpression che rappresenta un'istruzione break con il tipo specificato.Creates a GotoExpression representing a break statement with the specified type. Il valore passato all'etichetta al momento del passaggio può essere specificato.The value passed to the label upon jumping can be specified.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione break con il tipo specificato.Creates a GotoExpression representing a break statement with the specified type.

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

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo che non accetta argomenti.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)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo che accetta due argomenti.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)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo che accetta tre argomenti.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[])

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo che accetta argomenti.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>)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo che accetta argomenti.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[])

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo tramite la chiamata al metodo factory appropriato.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)

Crea un oggetto MethodCallExpression che rappresenta una chiamata al metodo static (Shared in Visual Basic) che accetta un argomento.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)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo statico che accetta due argomenti.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)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo statico che accetta tre argomenti.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)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo statico che accetta quattro argomenti.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)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo statico che accetta cinque argomenti.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[])

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo static (Shared in Visual Basic) con argomenti.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>)

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo statico (Shared in 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[])

Crea un oggetto MethodCallExpression che rappresenta una chiamata a un metodo static (Shared in Visual Basic) tramite la chiamata al metodo factory appropriato.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)

Crea un oggetto CatchBlock che rappresenta un'istruzione catch con un riferimento all'oggetto Exception intercettato per l'uso nel corpo del gestore.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)

Crea un oggetto CatchBlock che rappresenta un'istruzione catch con un filtro Exception e un riferimento all'oggetto Exception intercettato.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)

Crea un oggetto CatchBlock che rappresenta un'istruzione catch.Creates a CatchBlock representing a catch statement.

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

Crea un oggetto CatchBlock che rappresenta un'istruzione catch con un filtro Exception ma nessun riferimento all'oggetto Exception intercettato.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)

Crea un oggetto DebugInfoExpression per la cancellazione di un punto di sequenza.Creates a DebugInfoExpression for clearing a sequence point.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione coalescing.Creates a BinaryExpression that represents a coalescing operation.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione coalescing, data una funzione di conversione.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)

Crea un oggetto ConditionalExpression che rappresenta un'istruzione condizionale.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)

Crea un oggetto ConditionalExpression che rappresenta un'istruzione condizionale.Creates a ConditionalExpression that represents a conditional statement.

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

Crea un oggetto ConstantExpression la cui proprietà Value è impostata sul valore specificato.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)

Crea un oggetto ConstantExpression le cui proprietà Value e Type sono impostate sui valori specificati.Creates a ConstantExpression that has the Value and Type properties set to the specified values.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione continue.Creates a GotoExpression representing a continue statement.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione continue con il tipo specificato.Creates a GotoExpression representing a continue statement with the specified type.

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

Crea un oggetto UnaryExpression che rappresenta un'operazione di conversione di tipo.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)

Crea un oggetto UnaryExpression che rappresenta un'operazione di conversione per la quale è specificato il metodo di implementazione.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)

Crea un oggetto UnaryExpression che rappresenta un'operazione di conversione che genera un'eccezione in caso di overflow del tipo di destinazione.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)

Crea un oggetto UnaryExpression che rappresenta un'operazione di conversione che genera un'eccezione in caso di overflow del tipo di destinazione e per la quale è specificato il metodo di implementazione.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)

Crea un oggetto DebugInfoExpression con l'intervallo specificato.Creates a DebugInfoExpression with the specified span.

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

Crea un oggetto UnaryExpression che rappresenta il decremento dell'espressione di 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)

Crea un oggetto UnaryExpression che rappresenta il decremento dell'espressione di 1.Creates a UnaryExpression that represents the decrementing of the expression by 1.

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

Crea un oggetto DefaultExpression la cui proprietà Type è impostata sul tipo specificato.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di divisione aritmetica.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di divisione aritmetica.Creates a BinaryExpression that represents an arithmetic division operation. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di divisione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di divisione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di divisione che non ha il controllo dell'overflow.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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[])

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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>)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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[])

Crea un oggetto ElementInit, data una matrice di valori come secondo argomento.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>)

Crea un oggetto ElementInit, dato IEnumerable<T> come secondo argomento.Creates an ElementInit, given an IEnumerable<T> as the second argument.

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

Crea un'espressione vuota di tipo Void.Creates an empty expression that has Void type.

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

Crea un oggetto BinaryExpression che rappresenta un confronto di uguaglianza.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)

Crea un oggetto BinaryExpression che rappresenta un confronto di uguaglianza.Creates a BinaryExpression that represents an equality comparison. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Determina se l'oggetto specificato è uguale all'oggetto corrente.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione XOR bit per bit, usando op_ExclusiveOr per i tipi definiti dall'utente.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione XOR bit per bit, usando op_ExclusiveOr per i tipi definiti dall'utente.Creates a BinaryExpression that represents a bitwise XOR operation, using op_ExclusiveOr for user-defined types. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione XOR bit per bit, usando op_ExclusiveOr per i tipi definiti dall'utente.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione XOR bit per bit, usando op_ExclusiveOr per i tipi definiti dall'utente.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione XOR bit per bit, usando op_ExclusiveOr per i tipi definiti dall'utente.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)

Crea un oggetto MemberExpression che rappresenta l'accesso a un campo.Creates a MemberExpression that represents accessing a field.

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

Crea un oggetto MemberExpression che rappresenta l'accesso a un campo, dato il nome del campo.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)

Crea un oggetto MemberExpression che rappresenta l'accesso a un campo.Creates a MemberExpression that represents accessing a field.

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

Crea un oggetto Type che rappresenta un tipo delegato System.Action generico con argomenti tipo specifici.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[])

Ottiene un oggetto Type che rappresenta un tipo delegato System.Func o System.Action generico con argomenti tipo specifici.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[])

Crea un oggetto Type che rappresenta un tipo delegato System.Func generico con argomenti tipo specifici.Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. L'ultimo argomento di tipo specifica il tipo restituito del delegato creato.The last type argument specifies the return type of the created delegate.

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

Funge da funzione hash predefinita.Serves as the default hash function.

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

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione "go to".Creates a GotoExpression representing a "go to" statement.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione "go to".Creates a GotoExpression representing a "go to" statement. Il valore passato all'etichetta al momento del passaggio può essere specificato.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)

Crea un oggetto GotoExpression che rappresenta un'istruzione "go to" con il tipo specificato.Creates a GotoExpression representing a "go to" statement with the specified type. Il valore passato all'etichetta al momento del passaggio può essere specificato.The value passed to the label upon jumping can be specified.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione "go to" con il tipo specificato.Creates a GotoExpression representing a "go to" statement with the specified type.

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

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "maggiore di".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)

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "maggiore di".Creates a BinaryExpression that represents a "greater than" numeric comparison. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "maggiore o uguale a".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)

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "maggiore o uguale a".Creates a BinaryExpression that represents a "greater than or equal" numeric comparison.

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

Crea un oggetto ConditionalExpression che rappresenta un blocco condizionale con un'istruzione if.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)

Crea un oggetto ConditionalExpression che rappresenta un blocco condizionale con le istruzioni if e else.Creates a ConditionalExpression that represents a conditional block with if and else statements.

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

Crea un oggetto UnaryExpression che rappresenta l'incremento del valore dell'espressione di 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)

Crea un oggetto UnaryExpression che rappresenta l'incremento dell'espressione di 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[])

Crea un oggetto InvocationExpression che applica un delegato o un'espressione lambda a un elenco di espressioni di argomento.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>)

Crea un oggetto InvocationExpression che applica un delegato o un'espressione lambda a un elenco di espressioni di argomento.Creates an InvocationExpression that applies a delegate or lambda expression to a list of argument expressions.

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

Restituisce un valore che indica se l'espressione restituisce false.Returns whether the expression evaluates to false.

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

Restituisce un valore che indica se l'espressione restituisce false.Returns whether the expression evaluates to false.

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

Restituisce un valore che indica se l'espressione restituisce true.Returns whether the expression evaluates to true.

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

Restituisce un valore che indica se l'espressione restituisce true.Returns whether the expression evaluates to true.

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

Crea un oggetto LabelTarget che rappresenta un'etichetta con tipo void e nessun nome.Creates a LabelTarget representing a label with void type and no name.

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

Crea un oggetto LabelExpression che rappresenta un'etichetta senza un valore predefinito.Creates a LabelExpression representing a label without a default value.

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

Crea un oggetto LabelExpression che rappresenta un'etichetta con il valore predefinito specificato.Creates a LabelExpression representing a label with the given default value.

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

Crea un oggetto LabelTarget che rappresenta un'etichetta con tipo void e il nome specificato.Creates a LabelTarget representing a label with void type and the given name.

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

Crea un oggetto LabelTarget che rappresenta un'etichetta con il tipo specificato.Creates a LabelTarget representing a label with the given type.

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

Crea un oggetto LabelTarget che rappresenta un'etichetta con il tipo e il nome specificati.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>)

Crea un LambdaExpression costruendo prima un tipo delegato dal corpo dell'espressione, un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata, e una raccolta enumerabile di espressioni per i parametri.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. Può essere usato quando il tipo delegato non è noto in fase di compilazione.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[])

Crea un LambdaExpression costruendo prima un tipo delegato dal corpo dell'espressione, un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata, e una matrice di espressioni per i parametri.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. Può essere usato quando il tipo delegato non è noto in fase di compilazione.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>)

Crea un LambdaExpression costruendo prima un tipo delegato dal corpo dell'espressione e una raccolta enumerabile di espressioni per i parametri.Creates a LambdaExpression by first constructing a delegate type from the expression body, and an enumerable collection of parameter expressions. Può essere usato quando il tipo delegato non è noto in fase di compilazione.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[])

Crea un LambdaExpression costruendo prima un tipo delegato dal corpo dell'espressione e una matrice di espressioni per i parametri.Creates a LambdaExpression by first constructing a delegate type from the expression body, and an array of parameter expressions. Può essere usato quando il tipo delegato non è noto in fase di compilazione.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>)

Crea un LambdaExpression costruendo prima un tipo delegato dal corpo dell'espressione, il nome per l'espressione lambda, un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata e una raccolta enumerabile di espressioni per i parametri.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. Può essere usato quando il tipo delegato non è noto in fase di compilazione.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>)

Crea un LambdaExpression costruendo prima un tipo delegato dal corpo dell'espressione, il nome dell'espressione lambda, e una raccolta enumerabile di espressioni per i parametri.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. Può essere usato quando il tipo delegato non è noto in fase di compilazione.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>)

Crea un LambdaExpression in cui il tipo delegato è noto in fase di compilazione, con un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata e una raccolta enumerabile di espressioni per i parametri.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[])

Crea un LambdaExpression in cui il tipo delegato è noto in fase di compilazione, con un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata e una matrice di espressioni per i parametri.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>)

Crea un LambdaExpression in cui il tipo delegato è noto in fase di compilazione, con una raccolta enumerabile di espressioni per i parametri.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[])

Crea un LambdaExpression in cui il tipo delegato è noto in fase di compilazione, con una matrice di espressioni per i parametri.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>)

Crea un LambdaExpression in cui il tipo delegato è noto in fase di compilazione, con il nome per l'espressione lambda, un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata e una raccolta enumerabile di espressioni per i parametri.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>)

Crea un LambdaExpression in cui il tipo delegato è noto in fase di compilazione, con il nome dell'espressione lambda e una raccolta enumerabile di espressioni per i parametri.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>)

Crea un Expression<TDelegate> in cui il tipo delegato è noto in fase di compilazione, con un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata e una raccolta enumerabile di espressioni per i parametri.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[])

Crea un Expression<TDelegate> in cui il tipo delegato è noto in fase di compilazione, con un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata e una matrice di espressioni per i parametri.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>)

Crea un Expression<TDelegate> in cui il tipo di delegato è noto in fase di compilazione, con una raccolta enumerabile di espressioni per i parametri.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[])

Crea un Expression<TDelegate> in cui il tipo delegato è noto in fase di compilazione, con una matrice di espressioni per i parametri.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>)

Crea un Expression<TDelegate> in cui il tipo delegato è noto in fase di compilazione, con il nome per l'espressione lambda, un parametro che indica se l'ottimizzazione della chiamata tail verrà applicata e una raccolta enumerabile di espressioni per i parametri.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>)

Crea un Expression<TDelegate> in cui il tipo delegato è noto in fase di compilazione, con il nome dell'espressione lambda e una raccolta enumerabile di espressioni per i parametri.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di spostamento a sinistra bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di spostamento a sinistra bit per bit.Creates a BinaryExpression that represents a bitwise left-shift operation.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di spostamento a sinistra bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di spostamento a sinistra bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di spostamento a sinistra bit per bit.Creates a BinaryExpression that represents a bitwise left-shift assignment operation.

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

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "minore di".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)

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "minore di".Creates a BinaryExpression that represents a "less than" numeric comparison.

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

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "minore o uguale a".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)

Crea un oggetto BinaryExpression che rappresenta un confronto numerico "minore o uguale a".Creates a BinaryExpression that represents a "less than or equal" numeric comparison.

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

Crea un oggetto MemberListBinding dove il membro è un campo o una proprietà.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>)

Crea un oggetto MemberListBinding dove il membro è un campo o una proprietà.Creates a MemberListBinding where the member is a field or property.

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

Crea un oggetto MemberListBinding basato su un metodo della funzione di accesso alle proprietà specificato.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>)

Crea un oggetto MemberListBinding basato su un metodo della funzione di accesso alle proprietà specificato.Creates a MemberListBinding based on a specified property accessor method.

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

Crea un oggetto ListInitExpression che usa gli oggetti ElementInit specificati per inizializzare una raccolta.Creates a ListInitExpression that uses specified ElementInit objects to initialize a collection.

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

Crea un oggetto ListInitExpression che usa un metodo denominato "Add" per aggiungere elementi a una raccolta.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>)

Crea un oggetto ListInitExpression che usa gli oggetti ElementInit specificati per inizializzare una raccolta.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>)

Crea un oggetto ListInitExpression che usa un metodo denominato "Add" per aggiungere elementi a una raccolta.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[])

Crea un oggetto ListInitExpression che usa un metodo specificato per aggiungere elementi a una raccolta.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>)

Crea un oggetto ListInitExpression che usa un metodo specificato per aggiungere elementi a una raccolta.Creates a ListInitExpression that uses a specified method to add elements to a collection.

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

Crea un oggetto LoopExpression con il corpo specificato.Creates a LoopExpression with the given body.

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

Crea un oggetto LoopExpression con il corpo e la destinazione di interruzione specificati.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)

Crea un oggetto LoopExpression con il corpo specificato.Creates a LoopExpression with the given body.

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

Crea un oggetto BinaryExpression tramite la chiamata al metodo factory appropriato, dati gli operandi sinistro e destro.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)

Crea un oggetto BinaryExpression tramite la chiamata al metodo factory appropriato, dati gli operandi sinistro e destro e il metodo di implementazione.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)

Crea un oggetto BinaryExpression tramite la chiamata al metodo factory appropriato, dati gli operandi sinistro e destro, il metodo di implementazione e la funzione di conversione di tipi.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)

Crea un oggetto CatchBlock che rappresenta un'istruzione catch con gli elementi specificati.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato e da un argomento.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato e da due argomenti.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato e da tre argomenti.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)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato e da quattro argomenti.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[])

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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>)

Crea un oggetto DynamicExpression che rappresenta un'operazione dinamica associata dall'oggetto CallSiteBinder specificato.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)

Crea un oggetto GotoExpression che rappresenta un passaggio dell'oggetto GotoExpressionKind specificato.Creates a GotoExpression representing a jump of the specified GotoExpressionKind. Anche il valore passato all'etichetta al momento del passaggio può essere specificato.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>)

Crea un oggetto IndexExpression che rappresenta l'accesso a una proprietà indicizzata in un oggetto.Creates an IndexExpression that represents accessing an indexed property in an object.

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

Crea un oggetto MemberExpression che rappresenta l'accesso a un campo o a una proprietà.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>)

Crea un oggetto TryExpression che rappresenta un blocco try con gli elementi specificati.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)

Crea un oggetto UnaryExpression tramite la chiamata al metodo factory appropriato, dato un operando.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)

Crea un oggetto UnaryExpression tramite la chiamata al metodo factory appropriato, dato un operando e il metodo di implementazione.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>)

Crea un oggetto MemberMemberBinding che rappresenta l'inizializzazione ricorsiva di membri di un campo o una proprietà.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[])

Crea un oggetto MemberMemberBinding che rappresenta l'inizializzazione ricorsiva di membri di un campo o una proprietà.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>)

Crea un oggetto MemberMemberBinding che rappresenta l'inizializzazione ricorsiva di membri di un membro a cui si accede usando un metodo della funzione di accesso della proprietà.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[])

Crea un oggetto MemberMemberBinding che rappresenta l'inizializzazione ricorsiva di membri di un membro a cui si accede usando un metodo della funzione di accesso della proprietà.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>)

Rappresenta un'espressione che crea un nuovo oggetto e inizializza una proprietà dell'oggetto.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[])

Crea un oggetto MemberInitExpression.Creates a MemberInitExpression.

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

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di resto aritmetico.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di resto aritmetico.Creates a BinaryExpression that represents an arithmetic remainder operation.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di resto.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di resto.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di resto.Creates a BinaryExpression that represents a remainder assignment operation.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di moltiplicazione aritmetica che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di moltiplicazione aritmetica che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di moltiplicazione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di moltiplicazione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di moltiplicazione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di moltiplicazione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di moltiplicazione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di moltiplicazione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di moltiplicazione aritmetica che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di moltiplicazione aritmetica che ha il controllo dell'overflow.Creates a BinaryExpression that represents an arithmetic multiplication operation that has overflow checking.

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

Crea un oggetto UnaryExpression che rappresenta un'operazione di negazione aritmetica.Creates a UnaryExpression that represents an arithmetic negation operation.

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

Crea un oggetto UnaryExpression che rappresenta un'operazione di negazione aritmetica.Creates a UnaryExpression that represents an arithmetic negation operation.

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

Crea un oggetto UnaryExpression che rappresenta un'operazione di negazione aritmetica che ha il controllo dell'overflow.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)

Crea un oggetto UnaryExpression che rappresenta un'operazione di negazione aritmetica che ha il controllo dell'overflow.Creates a UnaryExpression that represents an arithmetic negation operation that has overflow checking. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto NewExpression che rappresenta la chiamata al costruttore specificato che non accetta argomenti.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[])

Crea un oggetto NewExpression che rappresenta la chiamata al costruttore specificato con gli argomenti specificati.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>)

Crea un oggetto NewExpression che rappresenta la chiamata al costruttore specificato con gli argomenti specificati.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>)

Crea un oggetto NewExpression che rappresenta la chiamata al costruttore specificato con gli argomenti specificati.Creates a NewExpression that represents calling the specified constructor with the specified arguments. I membri che accedono ai campi inizializzati del costruttore sono specificati.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[])

Crea un oggetto NewExpression che rappresenta la chiamata al costruttore specificato con gli argomenti specificati.Creates a NewExpression that represents calling the specified constructor with the specified arguments. I membri che accedono ai campi inizializzati del costruttore sono specificati come matrice.The members that access the constructor initialized fields are specified as an array.

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

Crea un oggetto NewExpression che rappresenta la chiamata al costruttore senza parametri del tipo specificato.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[])

Crea un oggetto NewArrayExpression che rappresenta la creazione di una matrice con una classificazione specificata.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>)

Crea un oggetto NewArrayExpression che rappresenta la creazione di una matrice con una classificazione specificata.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[])

Crea un oggetto NewArrayExpression che rappresenta la creazione di una matrice unidimensionale e la relativa inizializzazione da un elenco di elementi.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>)

Crea un oggetto NewArrayExpression che rappresenta la creazione di una matrice unidimensionale e la relativa inizializzazione da un elenco di elementi.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)

Crea un oggetto UnaryExpression che rappresenta un'operazione di complemento bit per bit.Creates a UnaryExpression that represents a bitwise complement operation.

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

Crea un oggetto UnaryExpression che rappresenta un'operazione di complemento bit per bit.Creates a UnaryExpression that represents a bitwise complement operation. Il metodo di implementazione può essere specificato.The implementing method can be specified.

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

Crea un oggetto BinaryExpression che rappresenta un confronto di disuguaglianza.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)

Crea un oggetto BinaryExpression che rappresenta un confronto di disuguaglianza.Creates a BinaryExpression that represents an inequality comparison.

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

Restituisce l'espressione che rappresenta il complemento a uno.Returns the expression representing the ones complement.

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

Restituisce l'espressione che rappresenta il complemento a uno.Returns the expression representing the ones complement.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione OR bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione OR bit per bit.Creates a BinaryExpression that represents a bitwise OR operation.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione OR bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione OR bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione OR bit per bit.Creates a BinaryExpression that represents a bitwise OR assignment operation.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione OR condizionale che valuta il secondo operando solo se il primo operando restituisce 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)

Crea un oggetto BinaryExpression che rappresenta un'operazione OR condizionale che valuta il secondo operando solo se il primo operando restituisce 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)

Crea un nodo ParameterExpression che può essere usato per identificare un parametro o una variabile in un albero delle espressioni.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)

Crea un nodo ParameterExpression che può essere usato per identificare un parametro o una variabile in un albero delle espressioni.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)

Crea un oggetto UnaryExpression che rappresenta l'assegnazione dell'espressione seguita da un successivo decremento di 1 dell'espressione originale.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)

Crea un oggetto UnaryExpression che rappresenta l'assegnazione dell'espressione seguita da un successivo decremento di 1 dell'espressione originale.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)

Crea un oggetto UnaryExpression che rappresenta l'assegnazione dell'espressione seguita da un successivo incremento di 1 dell'espressione originale.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)

Crea un oggetto UnaryExpression che rappresenta l'assegnazione dell'espressione seguita da un successivo incremento di 1 dell'espressione originale.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)

Crea un oggetto BinaryExpression che rappresenta l'elevamento di un numero a una potenza.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)

Crea un oggetto BinaryExpression che rappresenta l'elevamento di un numero a una potenza.Creates a BinaryExpression that represents raising a number to a power.

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

Crea un oggetto BinaryExpression che rappresenta l'elevamento di un'espressione a una potenza e l'assegnazione del risultato all'espressione.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)

Crea un oggetto BinaryExpression che rappresenta l'elevamento di un'espressione a una potenza e l'assegnazione del risultato all'espressione.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)

Crea un oggetto BinaryExpression che rappresenta l'elevamento di un'espressione a una potenza e l'assegnazione del risultato all'espressione.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)

Crea un oggetto UnaryExpression che decrementa l'espressione di 1 e assegna di nuovo il risultato all'espressione.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)

Crea un oggetto UnaryExpression che decrementa l'espressione di 1 e assegna di nuovo il risultato all'espressione.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)

Crea un oggetto UnaryExpression che incrementa l'espressione di 1 e assegna di nuovo il risultato all'espressione.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)

Crea un oggetto UnaryExpression che incrementa l'espressione di 1 e assegna di nuovo il risultato all'espressione.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)

Crea un oggetto MemberExpression che rappresenta l'accesso a una proprietà tramite un metodo della funzione di accesso alle proprietà.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)

Crea un oggetto MemberExpression che rappresenta l'accesso a una proprietà.Creates a MemberExpression that represents accessing a property.

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

Crea un oggetto IndexExpression che rappresenta l'accesso a una proprietà indicizzata.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>)

Crea un oggetto IndexExpression che rappresenta l'accesso a una proprietà indicizzata.Creates an IndexExpression representing the access to an indexed property.

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

Crea un oggetto MemberExpression che rappresenta l'accesso a una proprietà.Creates a MemberExpression that represents accessing a property.

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

Crea un oggetto IndexExpression che rappresenta l'accesso a una proprietà indicizzata.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)

Crea un oggetto MemberExpression che accede a una proprietà.Creates a MemberExpression accessing a property.

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

Crea un oggetto MemberExpression che rappresenta l'accesso a una proprietà o un campo.Creates a MemberExpression that represents accessing a property or field.

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

Crea un oggetto UnaryExpression che rappresenta un'espressione che ha un valore costante di tipo Expression.Creates a UnaryExpression that represents an expression that has a constant value of type Expression.

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

Riduce questo nodo a un'espressione più semplice.Reduces this node to a simpler expression. Se CanReduce restituisce true, deve essere restituita un'espressione valida.If CanReduce returns true, this should return a valid expression. Questo metodo può restituire un altro nodo che deve essere a sua volta ridotto.This method can return another node which itself must be reduced.

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

Riduce questo nodo a un'espressione più semplice.Reduces this node to a simpler expression. Se CanReduce restituisce true, deve essere restituita un'espressione valida.If CanReduce returns true, this should return a valid expression. Questo metodo può restituire un altro nodo che deve essere a sua volta ridotto.This method can return another node which itself must be reduced.

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

Riduce l'espressione a un tipo di nodo noto (diverso da un nodo di estensione) o restituisce solo l'espressione se è già un tipo noto.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)

Crea un oggetto BinaryExpression che rappresenta un confronto di uguaglianze di riferimento.Creates a BinaryExpression that represents a reference equality comparison.

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

Crea un oggetto BinaryExpression che rappresenta un confronto di disuguaglianze di riferimento.Creates a BinaryExpression that represents a reference inequality comparison.

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

Crea un oggetto UnaryExpression che rappresenta la rigenerazione di un'eccezione.Creates a UnaryExpression that represents a rethrowing of an exception.

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

Crea un oggetto UnaryExpression che rappresenta la rigenerazione di un'eccezione con un tipo specificato.Creates a UnaryExpression that represents a rethrowing of an exception with a given type.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione return.Creates a GotoExpression representing a return statement.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione return.Creates a GotoExpression representing a return statement. Il valore passato all'etichetta al momento del passaggio può essere specificato.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)

Crea un oggetto GotoExpression che rappresenta un'istruzione return con il tipo specificato.Creates a GotoExpression representing a return statement with the specified type. Il valore passato all'etichetta al momento del passaggio può essere specificato.The value passed to the label upon jumping can be specified.

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

Crea un oggetto GotoExpression che rappresenta un'istruzione return con il tipo specificato.Creates a GotoExpression representing a return statement with the specified type.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di spostamento a destra bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di spostamento a destra bit per bit.Creates a BinaryExpression that represents a bitwise right-shift operation.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di spostamento a destra bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di spostamento a destra bit per bit.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di spostamento a destra bit per bit.Creates a BinaryExpression that represents a bitwise right-shift assignment operation.

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

Crea un'istanza di RuntimeVariablesExpression.Creates an instance of RuntimeVariablesExpression.

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

Crea un'istanza di RuntimeVariablesExpression.Creates an instance of RuntimeVariablesExpression.

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

Crea un oggetto BinaryExpression che rappresenta un'operazione di sottrazione aritmetica che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di sottrazione aritmetica che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di sottrazione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di sottrazione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di sottrazione che non ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di sottrazione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di sottrazione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di assegnazione di sottrazione che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di sottrazione aritmetica che ha il controllo dell'overflow.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)

Crea un oggetto BinaryExpression che rappresenta un'operazione di sottrazione aritmetica che ha il controllo dell'overflow.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>)

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.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[])

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.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[])

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.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[])

Crea un oggetto a SwitchExpression che rappresenta un'istruzioneswitch senza un case predefinito.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>)

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.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[])

Crea SwitchExpression che rappresenta un'istruzione switch con un caso predefinito.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[])

Crea un oggetto SwitchCase da usare in un oggetto 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>)

Crea un oggetto SwitchCase da usare in un oggetto SwitchExpression.Creates a SwitchCase object to be used in a SwitchExpression object.

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

Crea un'istanza di SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

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

Crea un'istanza di SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

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

Crea un'istanza di 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)

Crea un'istanza di SymbolDocumentInfo.Creates an instance of SymbolDocumentInfo.

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

Crea un oggetto UnaryExpression che rappresenta la generazione di un'eccezione.Creates a UnaryExpression that represents a throwing of an exception.

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

Crea un oggetto UnaryExpression che rappresenta la generazione di un'eccezione con un tipo specificato.Creates a UnaryExpression that represents a throwing of an exception with a given type.

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

Restituisce una rappresentazione testuale di Expression.Returns a textual representation of the Expression.

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

Crea un oggetto TryExpression che rappresenta un blocco try con qualsiasi numero di istruzioni catch e nessun blocco fault o 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[])

Crea un oggetto TryExpression che rappresenta un blocco try con qualsiasi numero di istruzioni catch e un blocco 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)

Crea un oggetto a TryExpression che rappresenta un blocco try con un blocco fault e nessuna istruzione catch.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)

Crea un oggetto TryExpression che rappresenta un blocco try con un blocco finally e nessuna istruzione catch.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)

Crea un oggetto Type che rappresenta un tipo delegato System.Action generico con argomenti di tipo specifici.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)

Crea un oggetto Type che rappresenta un tipo delegato System.Func generico con argomenti di tipo specifici.Creates a Type object that represents a generic System.Func delegate type that has specific type arguments. L'ultimo argomento di tipo specifica il tipo restituito del delegato creato.The last type argument specifies the return type of the created delegate.

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

Crea un oggetto UnaryExpression che rappresenta un riferimento esplicito o una conversione boxing in cui viene fornito null se la conversione non riesce.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)

Crea un oggetto TypeBinaryExpression che confronta l'identità del tipo in fase di esecuzione.Creates a TypeBinaryExpression that compares run-time type identity.

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

Crea un oggetto TypeBinaryExpression.Creates a TypeBinaryExpression.

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

Crea un oggetto UnaryExpression che rappresenta un'operazione con il più unario.Creates a UnaryExpression that represents a unary plus operation.

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

Crea un oggetto UnaryExpression che rappresenta un'operazione con il più unario.Creates a UnaryExpression that represents a unary plus operation.

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

Crea un oggetto UnaryExpression che rappresenta una conversione unboxing esplicita.Creates a UnaryExpression that represents an explicit unboxing.

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

Crea un nodo ParameterExpression che può essere usato per identificare un parametro o una variabile in un albero delle espressioni.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)

Crea un nodo ParameterExpression che può essere usato per identificare un parametro o una variabile in un albero delle espressioni.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)

Riduce il nodo, quindi chiama il delegato del visitatore sull'espressione ridotta.Reduces the node and then calls the visitor delegate on the reduced expression. Se il nodo non è riducibile, il metodo genera un'eccezione.The method throws an exception if the node is not reducible.

Si applica a