0Pricing
C# Academy · Lekcja

Elementy składowe z treścią wyrażeniową

Pisz zwięzłe właściwości i metody.

Elementy składowe z treścią wyrażeniową to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 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.

Bardziej zwięzła składnia

Składnia ciała wyrażeniowego korzysta z =>, aby zdefiniować element jako pojedyncze wyrażenie, zastępując pełne ciało { ... }. Dzięki niej krótkie elementy są bardziej zwięzłe i czytelne.

using System;

class Greeter
{
    public string Hello() => "Hi there!";
}

class Program
{
    static void Main()
    {
        var g = new Greeter();
        Console.WriteLine(g.Hello());
    }
}

Metody z ciałem wyrażeniowym

Każda metoda, której ciało jest pojedynczym wyrażeniem, może korzystać z =>. Wynik wyrażenia staje się zwracaną wartością.

using System;

class MathHelper
{
    public int Square(int x) => x * x;
    public int Add(int a, int b) => a + b;
}

class Program
{
    static void Main()
    {
        var m = new MathHelper();
        Console.WriteLine(m.Square(6));
        Console.WriteLine(m.Add(3, 4));
    }
}

Właściwości tylko do odczytu z ciałem wyrażeniowym

Obliczana właściwość tylko do odczytu może korzystać z => zamiast get { return ...; }.

using System;

class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
    public double Area => Width * Height;
}

class Program
{
    static void Main()
    {
        var r = new Rectangle { Width = 4, Height = 5 };
        Console.WriteLine("Area: " + r.Area);
    }
}

Gettery i settery z ciałem wyrażeniowym

Akcesorom get i set również można nadać własne ciała wyrażeniowe, co jest przydatne w połączeniu z polem zapasowym.

using System;

class Person
{
    private string _name;
    public string Name
    {
        get => _name;
        set => _name = value.Trim();
    }
}

class Program
{
    static void Main()
    {
        var p = new Person();
        p.Name = "  Niki  ";
        Console.WriteLine("[" + p.Name + "]");
    }
}

Zwracanie obliczanych ciągów

Właściwości z ciałem wyrażeniowym doskonale nadają się do sformatowanych wartości pochodnych, takich jak pełne imiona i nazwiska lub etykiety.

using System;

class Customer
{
    public string First { get; set; }
    public string Last { get; set; }
    public string Display => First + " " + Last;
}

class Program
{
    static void Main()
    {
        var c = new Customer { First = "Ada", Last = "Lovelace" };
        Console.WriteLine(c.Display);
    }
}

Ciała wyrażeniowe z warunkami

Pojedyncze wyrażenie może zawierać operator warunkowy (trójargumentowy), dzięki czemu logika rozgałęzień mieści się w jednym wierszu.

using System;

class Account
{
    public decimal Balance { get; set; }
    public string Status => Balance >= 0 ? "OK" : "Overdrawn";
}

class Program
{
    static void Main()
    {
        var a = new Account { Balance = -20m };
        Console.WriteLine(a.Status);
    }
}

Metody void z ciałem wyrażeniowym

Metoda wykonująca działanie i niczego niezwracająca również może mieć ciało wyrażeniowe, jeśli działanie składa się z pojedynczej instrukcji.

using System;

class Logger
{
    public void Log(string msg) => Console.WriteLine("[LOG] " + msg);
}

class Program
{
    static void Main()
    {
        var log = new Logger();
        log.Log("Started");
    }
}

Konstruktory z ciałem wyrażeniowym

Konstruktor zawierający jedno przypisanie również może korzystać ze składni strzałkowej.

using System;

class Point
{
    public int X { get; }
    public Point(int x) => X = x;
}

class Program
{
    static void Main()
    {
        var p = new Point(7);
        Console.WriteLine("X = " + p.X);
    }
}

Kiedy NIE należy jej używać

Ciała wyrażeniowe służą wyłącznie do zapisywania pojedynczych wyrażeń. Jeśli potrzebne są Państwu dodatkowe instrukcje, pętle lub rozgałęzienia walidacji, należy użyć zwykłego ciała blokowego.

using System;

class Calculator
{
    // Single expression -> arrow is fine
    public int Triple(int n) => n * 3;

    // Multiple statements -> use a block
    public int SumTo(int n)
    {
        int total = 0;
        for (int i = 1; i <= n; i++) total += i;
        return total;
    }
}

class Program
{
    static void Main()
    {
        var c = new Calculator();
        Console.WriteLine(c.Triple(4));
        Console.WriteLine(c.SumTo(5));
    }
}

Łączenie wielu elementów w jednej klasie

Niewielka klasa może korzystać ze składni strzałkowej niemal dla każdego elementu, znacznie ograniczając ilość kodu pomocniczego.

using System;

class Temperature
{
    public double Celsius { get; set; }
    public double Fahrenheit => Celsius * 9 / 5 + 32;
    public double Kelvin => Celsius + 273.15;
    public override string ToString() => Celsius + "C";
}

class Program
{
    static void Main()
    {
        var t = new Temperature { Celsius = 25 };
        Console.WriteLine(t + " = " + t.Fahrenheit + "F = " + t.Kelvin + "K");
    }
}

Połączenie elementów

Proszę używać elementów z ciałem wyrażeniowym, aby zachować przejrzystość prostych getterów, metod pomocniczych i metod jednowierszowych, a ciała blokowe pozostawić dla właściwej logiki.

using System;

class Order
{
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total => Quantity * UnitPrice;
    public bool IsLarge => Quantity > 10;
}

class Program
{
    static void Main()
    {
        var o = new Order { Quantity = 12, UnitPrice = 9.99m };
        Console.WriteLine("Total: " + o.Total + ", Large: " + o.IsLarge);
    }
}

Szybkie sprawdzenie

Proszę sprawdzić zrozumienie elementów z ciałem wyrażeniowym.

Podsumowanie

Elementy z ciałem wyrażeniowym korzystają z =>, aby definiować element za pomocą pojedynczego wyrażenia. Można ich używać w metodach, właściwościach tylko do odczytu, pojedynczych akcesorach get/set, a nawet konstruktorach. Należy stosować je do zwięzłych konstrukcji jednowierszowych, a po napotkaniu potrzeby użycia wielu instrukcji przejść na ciało blokowe.

using System;

class Demo
{
    public int N { get; set; }
    public int Doubled => N * 2;
    public string Label() => "N is " + N;
}

class Program
{
    static void Main()
    {
        var d = new Demo { N = 9 };
        Console.WriteLine(d.Label() + ", doubled = " + d.Doubled);
    }
}

Często zadawane pytania

Czy lekcja „Elementy składowe z treścią wyrażeniową” jest bezpłatna?

Tak — pełny tekst „Elementy składowe z treścią wyrażeniową” 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 „Elementy składowe z treścią wyrażeniową”?

Pisz zwięzłe właściwości i metody. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Elementy składowe z treścią wyrażeniową”?

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

  1. Właściwości implementowane automatycznie
  2. Pełne właściwości z polami zapasowymi
  3. Elementy składowe z treścią wyrażeniową
  4. Indeksery
← Powrót do C# Academy