İfade ağaçları (C# ve Visual Basic)

Makale
02/26/2013

İfade ağaçları burada her düğüm, bir ifade, örneğin bir ağaç benzeri veri yapısı, yöntem çağrısı veya ikili işlem kodu gibi temsil x < y.

Derleme ve ifade ağaçları tarafından temsil edilen kod çalıştırabilir.Bu dinamik değiştirilmesine yürütülebilir kod LINQ yürütülmesi çeşitli veritabanları ve dinamik sorgular oluşturma sorguları sağlar.LINQ ifadesi ağaçlar hakkında daha fazla bilgi için bkz: Nasıl yapılır: deyim ağaçları (C# ve Visual Basic) dinamik sorguları oluşturmak için kullanın ve İzlenecek yol: IQueryable LINQ sağlayıcısı oluşturma.

İfade ağaçları da dinamik dil çalıştırma (dlr) dinamik diller arasında birlikte çalışabilirliği sağlamak için kullanılır ve.net Framework ve Microsoft yerine ağaçları ifade Yaysın derleyici yazarları etkinleştirmek için dili (MSIL) orta düzeyde.dlr hakkında daha fazla bilgi için bkz: Dinamik dil çalıştırma genel bakış.

C# veya Visual Basic derleyici bir anonim lambda ifadeye dayalı veya kullanarak ifade ağaçları el ile oluşturabilirsiniz ifade ağaç oluşturmak olabilir System.Linq.Expressions ad.

Lambda ifadeleri ifade ağaçları oluşturma

Ne zaman lambda ifade atanmış türünde bir değişken Expression<TDelegate>, derleyicinin ürettiði kod lambda ifade eden bir ifade ağacını oluşturun.

C# ve Visual Basic derleyiciler ifade ağaçları yalnızca ifade lambdas (veya tek satırlı lambdas) oluşturabilir.Bu ifade lambdas (veya çok satırlı lambdas) ayrıştırılamadı.C# [NULL]'taki lambda ifadeleri hakkında daha fazla bilgi için bkz: Lambda ifadeleri (C# Programlama Kılavuzu); Visual Basic için bkz: Lambda ifadeleri (Visual Basic).

Aşağıdaki kod örnekleri olan C# göstermektedir ve Visual Basic derleyiciler lambda ifade eden bir ifade ağacı oluşturmak num => num < 5 (C#) veya Function(num) num < 5 (Visual Basic).

Dim lambda As Expression(Of Func(Of Integer, Boolean)) =
    Function(num) num < 5

Expression<Func<int, bool>> lambda = num => num < 5;

API kullanarak ifade ağaçları oluşturma

API kullanarak ifade ağaçları oluşturmak için Expression sınıfı.Bu sınıf ifade ağaç düğümlerini belirli türleri, örneğin, oluşturduğunuz statik Fabrika yöntemleri içeren ParameterExpression, bir değişkeni veya parametresi, temsil veya MethodCallExpression, gösteren bir yöntem çağrısı.ParameterExpression, MethodCallExpression, ifade özgü türleri de tanımlanır ve System.Linq.Expressions ad.Bu tür soyut türünden türetilmesi Expression.

Aşağıdaki kod örneği lambda ifade eden bir ifade ağaç oluşturulması gösterilmiştir num => num < 5 (C#) veya Function(num) num < 5 (Visual Basic) API kullanarak.


' Import the following namespace to your project: System.Linq.Expressions

' Manually build the expression tree for the lambda expression num => num < 5.
Dim numParam As ParameterExpression = Expression.Parameter(GetType(Integer), "num")
Dim five As ConstantExpression = Expression.Constant(5, GetType(Integer))
Dim numLessThanFive As BinaryExpression = Expression.LessThan(numParam, five)
Dim lambda1 As Expression(Of Func(Of Integer, Boolean)) =
  Expression.Lambda(Of Func(Of Integer, Boolean))(
        numLessThanFive,
        New ParameterExpression() {numParam})


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

            // Manually build the expression tree for 
            // the lambda expression num => num < 5.
            ParameterExpression numParam = Expression.Parameter(typeof(int), "num");
            ConstantExpression five = Expression.Constant(5, typeof(int));
            BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);
            Expression<Func<int, bool>> lambda1 =
                Expression.Lambda<Func<int, bool>>(
                    numLessThanFive,
                    new ParameterExpression[] { numParam });

.net Framework 4 ifade ağaçları API de destekler atamaları ve döngüleri, koşullu bloklar gibi denetim akışı deyimler ve try-catch engeller.API kullanarak daha karmaşık gelen lambda ifadeleri C# ve Visual Basic derleyiciler tarafından oluşturulabilen ifade ağaçlarını oluşturabilirsiniz.Aşağıdaki örnek, bir sayının çarpınımını hesaplar bir ifade ağaç oluşturulması gösterilmiştir.

' Creating a parameter expression.
Dim value As ParameterExpression =
    Expression.Parameter(GetType(Integer), "value")

' Creating an expression to hold a local variable. 
Dim result As ParameterExpression =
    Expression.Parameter(GetType(Integer), "result")

' Creating a label to jump to from a loop.
Dim label As LabelTarget = Expression.Label(GetType(Integer))

' Creating a method body.
Dim block As BlockExpression = Expression.Block(
    New ParameterExpression() {result},
    Expression.Assign(result, Expression.Constant(1)),
    Expression.Loop(
        Expression.IfThenElse(
            Expression.GreaterThan(value, Expression.Constant(1)),
            Expression.MultiplyAssign(result,
                Expression.PostDecrementAssign(value)),
            Expression.Break(label, result)
        ),
        label
    )
)

' Compile an expression tree and return a delegate.
Dim factorial As Integer =
    Expression.Lambda(Of Func(Of Integer, Integer))(block, value).Compile()(5)

Console.WriteLine(factorial)
' Prints 120.

// Creating a parameter expression.
ParameterExpression value = Expression.Parameter(typeof(int), "value");

// Creating an expression to hold a local variable. 
ParameterExpression result = Expression.Parameter(typeof(int), "result");

// Creating a label to jump to from a loop.
LabelTarget label = Expression.Label(typeof(int));

// Creating a method body.
BlockExpression block = Expression.Block(
    // Adding a local variable.
    new[] { result },
    // Assigning a constant to a local variable: result = 1
    Expression.Assign(result, Expression.Constant(1)),
    // Adding a loop.
        Expression.Loop(
    // Adding a conditional block into the loop.
           Expression.IfThenElse(
    // Condition: value > 1
               Expression.GreaterThan(value, Expression.Constant(1)),
    // If true: result *= value --
               Expression.MultiplyAssign(result,
                   Expression.PostDecrementAssign(value)),
    // If false, exit the loop and go to the label.
               Expression.Break(label, result)
           ),
    // Label to jump to.
       label
    )
);

// Compile and execute an expression tree.
int factorial = Expression.Lambda<Func<int, int>>(block, value).Compile()(5);

Console.WriteLine(factorial);
// Prints 120.

Daha fazla bilgi için bkz: Üretme dinamik yöntemleriyle Visual Studio 2010 ağaçlarında ifade.

İfade ağaç ayrıştırma

Nasıl ifade ağaç, aşağıdaki kod örneği göstermektedir lambda ifade temsil num => num < 5 (C#) veya Function(num) num < 5 (Visual Basic) alt bölümlere decomposed.


        ' Import the following namespace to your project: System.Linq.Expressions

        ' Create an expression tree.
        Dim exprTree As Expression(Of Func(Of Integer, Boolean)) = Function(num) num < 5

        ' Decompose the expression tree.
        Dim param As ParameterExpression = exprTree.Parameters(0)
        Dim operation As BinaryExpression = exprTree.Body
        Dim left As ParameterExpression = operation.Left
        Dim right As ConstantExpression = operation.Right

        Console.WriteLine(String.Format("Decomposed expression: {0} => {1} {2} {3}",
                          param.Name, left.Name, operation.NodeType, right.Value))

        ' This code produces the following output:
        '
        ' Decomposed expression: num => num LessThan 5


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

// Create an expression tree.
Expression<Func<int, bool>> exprTree = num => num < 5;

// Decompose the expression tree.
ParameterExpression param = (ParameterExpression)exprTree.Parameters[0];
BinaryExpression operation = (BinaryExpression)exprTree.Body;
ParameterExpression left = (ParameterExpression)operation.Left;
ConstantExpression right = (ConstantExpression)operation.Right;

Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}",
                  param.Name, left.Name, operation.NodeType, right.Value);

// This code produces the following output:

// Decomposed expression: num => num LessThan 5

İmmutability ifade ağaçları

İfade ağaçları sabit olmalıdır.Bu ifade ağaç değiştirmek isterseniz, yeni bir ifade ağaç varolan bir kopyalama ve değiştirme, düğümler tarafından oluşturmalıdır olduğunu anlamına gelir.Varolan ifadesi ağacında ilerlemelisiniz için ifade ağaç ziyaretçi kullanabilirsiniz.Daha fazla bilgi için bkz. Nasıl yapılır: deyim ağaçları (C# ve Visual Basic) değiştirme.

İfade ağaçları derleme

Expression<TDelegate> Türü sağlar Compile bir ifade ağaç tarafından yürütülebilir bir temsilci ile temsil edilen kodu derler yöntemi.

Aşağıdaki kod örneği, bir ifade ağacını derleyebilir ve sonuç kodunu çalıştırmak gösterilmiştir.

' Creating an expression tree.
Dim expr As Expression(Of Func(Of Integer, Boolean)) =
    Function(num) num < 5

' Compiling the expression tree into a delegate.
Dim result As Func(Of Integer, Boolean) = expr.Compile()

' Invoking the delegate and writing the result to the console.
Console.WriteLine(result(4))

' Prints True.

' You can also use simplified syntax
' to compile and run an expression tree.
' The following line can replace two previous statements.
Console.WriteLine(expr.Compile()(4))

' Also prints True.

// Creating an expression tree.
Expression<Func<int, bool>> expr = num => num < 5;

// Compiling the expression tree into a delegate.
Func<int, bool> result = expr.Compile();

// Invoking the delegate and writing the result to the console.
Console.WriteLine(result(4));

// Prints True.

// You can also use simplified syntax
// to compile and run an expression tree.
// The following line can replace two previous statements.
Console.WriteLine(expr.Compile()(4));

// Also prints True.

Daha fazla bilgi için bkz. Nasıl yapılır: yürütme ifade ağaçları (C# ve Visual Basic).

Ayrıca bkz.

Aracılığıyla paylaş

İfade ağaçları (C# ve Visual Basic)

Lambda ifadeleri ifade ağaçları oluşturma

API kullanarak ifade ağaçları oluşturma

İfade ağaç ayrıştırma

İmmutability ifade ağaçları

İfade ağaçları derleme

Ayrıca bkz.

Görevler

Başvuru

Kavramlar

Diğer Kaynaklar

Ek kaynaklar