A LINQ és az Expression osztály

Ahogy a LINQ bevezetÅ‘ben szó volt róla, a LINQ használható SQL rendszerek esetén is a megfelelÅ‘ kapcsolódási felülettel, de mégis hogy lesz C# kódból SQL kód, amit majd az adatbázis végrehajt? Emögött az Expression¹ osztály és az IQueryable ² felület áll. A LINQ szolgáltatóknak implementálniuk kell ezt a felületet.

Ez a felület egy LINQ kérésből készült kifejezés fát kap meg, ami alapján a felület implementálója valamilyen módon (pl. SQL utasítássorra fordítás után) .NET objektumokat tud visszaadni.

A kifejezésfa egy faszerű adatstruktúra, ahol minden csomópont egy kifejezés. Ez a kifejezés lehet egy metódushívás vagy egy bináris (két operandusú) művelet is. Használatuk lehetővé teszi a kód dinamikus módosítását is. Erre leginkább a keretrendszer DLR része épít.

Ezeket a fákat vizuálisan könnyebb elképzelni, ezért nézzük meg egy egyszerű kifejezés fáját:

int x = 3 + 2;

A faszerű kifejezéssé alakítás előnye, hogy fa bejáró algoritmusokkal egyszerűsíthető a kifejezés, illetve ki is értékelhető. Szinte minden modern fordítóprogram a beadott szöveges kódot valami gráfszerű belső reprezentációvá alakítja fordítás előtt.

LINQ esetén a megírt kódunkból kifejezésfát a fordító fog építeni és az IQueryable implementációnk híváskor már a felépített fát fogja megkapni egy Expression típusú objektum formájában. Az alábbi program az Expression osztály használatát mutatja be:

using System;
using System.Linq.Expressions;
using System.Reflection;

namespace PeldaExpressionTree
{
    public static class Program
    {
        public static void Main(string[] args)
        {
            //Lamba stílusú kifejezésfa építés
            Expression<Func<int, int, int>> osszead = (a, b) => a + b;

            //Kifejezésfa fordítása
            Func<int, int, int> osszeadLambda = osszead.Compile();

            //Meghívása
            int eredmeny = osszeadLambda(1, 2);

            Console.WriteLine("1 + 2 = {0}", eredmeny);

            //Komplex példa
            var HelloLambda = Hello();
            Console.WriteLine("Hello(\"Olvaso\") = {0}", HelloLambda("Olvaso"));

            Console.ReadKey();
        }

        private static Func<string, string> Hello()
        {
            ParameterExpression neve = Expression.Parameter(typeof(string), nameof(neve));

            MethodInfo IsNullOrEmptyMetodus = 
                typeof(string)
                .GetMethod(nameof(string.IsNullOrWhiteSpace));

            UnaryExpression feltetel 
                = Expression.Not(Expression.Call(IsNullOrEmptyMetodus, neve));

            var concatMetodus = 
                typeof(string).GetMethod(nameof(string.Concat), 
                new[] 
                { 
                    typeof(string),
                    typeof(string) 
                });

            var igazEset = 
                Expression.Call(concatMetodus, Expression.Constant("Hello, "), neve);

            ConstantExpression hamisEset = Expression.Constant(null, typeof(string));

            var lambda =
                Expression.Lambda<Func<string, string>>(
                    Expression.Condition(feltetel, igazEset, hamisEset),
                    neve);

            return lambda.Compile();
        }
    }
}

A program kimenete:

1 + 2 = 3
Hello("Olvaso") = Hello, Olvaso

Amint látható ,egy kifejezés fából tudunk egy lambda metódust csinálni a Compile() metódus meghívásával, amit utána végre tudunk hajtani, illetve ahogy látható, építÅ‘kövenlként tudunk kifejezéseket is generálni. Ez a HelloLambda létrehozásánál látható. Ennek a C# ekvivalens kódja:

string Hello(string neve)
{
    return !string.IsNullOrWhiteSpace(neve)) ? $"Hello, {neve}" : null;
}

A létrehozott Expression osztály immutable, hasonlóan a string osztályhoz, vagyis minden módosítás egy új kifejezést eredményez. A kifejezésekbÅ‘l felépített kód nem a legegyszerűbben olvasható. Ennek segítségével lehet dinamikusan kódot generálni és fordítani az alkalmazásunkban, de a bonyolultsága miatt nemigen kézenfekvÅ‘. Erre jó példa a szöveg összefűzése. Ehhez a string típuson ki kell keresnünk a megfelelÅ‘ szignatúrával rendelkezÅ‘ Concat metódust, majd paraméterezetten meghívnunk. Mindezt C# kód esetén a fordító a + operátor használatakor automatikusan megteszi számunkra. Ezért ha C# kódot szeretnénk generálni, akkor sokkal kézenfekvÅ‘bb a Roslyn API használata, mint ahogy azt a DLR esetén is láttuk a C# példában.

Ha véletlenül Expression osztályokkal kellene dolgoznunk a kódban, akkor mindenképpen hasznos kiegészítÅ‘ az Expression Tree Visualizer, ami kifejezésfák vizualizálását teszi lehetÅ‘vé Visual Studio debuggolás közben. A kiegészítÅ‘ a https://github.com/zspitz/ExpressionTreeVisualizer címrÅ‘l szerezhetÅ‘ be.

Összegezve tehát az Expression osztály leginkább LINQ provider-ek implementálásra lett kitalálva, ahol C# kódot kell átalakítanunk valami más nyelvre. Ehhez pedig egy C# kifejezésrÅ‘l tudnunk kell, hogy milyen elemekbÅ‘l épült fel.