C# Academy · Lekcja

Ręczne tworzenie wyrażeń

Konstruuj drzewa wyrażeń za pomocą interfejsu Expression API.

Lekcja 2 z 413 kroki

Ręczne tworzenie wyrażeń to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Ręczne tworzenie drzew

Oprócz możliwości zbudowania drzewa przez kompilator na podstawie lambdy można utworzyć je samodzielnie, korzystając ze statycznych metod fabrykujących klasy Expression.

using System;
using System.Linq.Expressions;

var five = Expression.Constant(5);
Console.WriteLine(five);          // 5
Console.WriteLine(five.Type);     // System.Int32

Expression.Parameter

Expression.Parameter(type, name) tworzy węzeł parametru, do którego można odwołać się w treści i powiązać go z lambdą.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
Console.WriteLine(x.Name + " : " + x.Type); // x : System.Int32

Expression.Constant

Expression.Constant(value) osadza literał. Opcjonalnie można określić jego typ.

using System;
using System.Linq.Expressions;

var c = Expression.Constant(42);
var typed = Expression.Constant(3.14, typeof(double));
Console.WriteLine(c + " " + typed); // 42 3.14

Expression.Add

Operatory binarne mają metody fabrykujące, takie jak Expression.Add. Przyjmują one dwa wyrażenia operandów i tworzą obiekt BinaryExpression.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var sum = Expression.Add(x, Expression.Constant(1));
Console.WriteLine(sum); // (x + 1)

Inne operatory binarne

Dostępne są metody fabrykujące dla całego zestawu operatorów: Subtract, Multiply, Divide, GreaterThan, Equal i innych.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var gt = Expression.GreaterThan(x, Expression.Constant(10));
var mul = Expression.Multiply(x, Expression.Constant(2));
Console.WriteLine(gt + " | " + mul); // (x > 10) | (x * 2)

Opakowanie w lambdę

Expression.Lambda łączy treść i parametry w obiekt Expression<TDelegate>, który można później skompilować.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var body = Expression.Add(x, Expression.Constant(1));
var lambda = Expression.Lambda<Func<int, int>>(body, x);
Console.WriteLine(lambda); // x => (x + 1)

Łączenie zagnieżdżonych wyrażeń

Metody fabrykujące można dowolnie zagnieżdżać, dzięki czemu złożone wyrażenia, takie jak (x + 1) * 2, można budować krok po kroku.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var addOne = Expression.Add(x, Expression.Constant(1));
var timesTwo = Expression.Multiply(addOne, Expression.Constant(2));
Console.WriteLine(timesTwo); // ((x + 1) * 2)

Dostęp do składowych

Expression.Property i Expression.Field tworzą węzły dostępu do składowych.

using System;
using System.Linq.Expressions;

var s = Expression.Parameter(typeof(string), "s");
var lengthAccess = Expression.Property(s, "Length");
Console.WriteLine(lengthAccess); // s.Length

Wywołania metod

Expression.Call tworzy węzeł wywołania na podstawie obiektu docelowego, metody i argumentów.

using System;
using System.Linq.Expressions;

var s = Expression.Parameter(typeof(string), "s");
var toUpper = typeof(string).GetMethod("ToUpper", Type.EmptyTypes);
var call = Expression.Call(s, toUpper);
Console.WriteLine(call); // s.ToUpper()

Sprawdzanie typów podczas budowania

Metody fabrykujące sprawdzają typy operandów podczas budowania drzewa. Niezgodne typy powodują natychmiastowy wyjątek, dzięki czemu błędy są wykrywane wcześniej.

using System;
using System.Linq.Expressions;

try {
    var bad = Expression.Add(
        Expression.Constant(1),
        Expression.Constant("text")); // int + string
} catch (InvalidOperationException) {
    Console.WriteLine("type mismatch rejected");
}

Zastosowanie w praktyce

Zbuduj w całości ręcznie lambdę x => (x + 1) * 2.

using System;
using System.Linq.Expressions;

var x = Expression.Parameter(typeof(int), "x");
var body = Expression.Multiply(
    Expression.Add(x, Expression.Constant(1)),
    Expression.Constant(2));
var lambda = Expression.Lambda<Func<int, int>>(body, x);
Console.WriteLine(lambda); // x => ((x + 1) * 2)

Szybkie sprawdzenie

Proszę sprawdzić, jak działa ręczne tworzenie wyrażeń.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Poznano sposób ręcznego budowania drzew wyrażeń.

Expression.Parameter i Expression.Constant tworzą węzły liści.
Expression.Add i podobne metody budują operacje binarne.
Expression.Property i Expression.Call obsługują składowe oraz metody.
Expression.Lambda składa drzewo, które można wywołać.

Bezpłatny start

Ucz się C# dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 93
Lekcje: 346

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Ręczne tworzenie wyrażeń” jest bezpłatna?

Tak — pełny tekst „Ręczne tworzenie wyrażeń” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Ręczne tworzenie wyrażeń”?

Konstruuj drzewa wyrażeń za pomocą interfejsu Expression API. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Ręczne tworzenie wyrażeń”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C# Academy