0Pricing
C# Academy · Lezione

Membri con corpo a espressione

Scriva proprietà e metodi compatti.

Membri con corpo a espressione è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Una sintassi più concisa

La sintassi con corpo a espressione usa => per definire un membro come una singola espressione, sostituendo un corpo completo { ... }. Rende i membri brevi più compatti e leggibili.

using System;

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

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

Metodi con corpo a espressione

Qualsiasi metodo il cui corpo è costituito da una singola espressione può usare =>. Il risultato dell'espressione diventa il valore restituito.

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));
    }
}

Proprietà in sola lettura con corpo a espressione

Una proprietà calcolata in sola lettura può usare => invece di 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);
    }
}

get e set con corpo a espressione

È inoltre possibile assegnare ai singoli accessor get e set un proprio corpo a espressione, una soluzione utile con un campo di supporto.

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 + "]");
    }
}

Restituire stringhe calcolate

Le proprietà con corpo a espressione sono particolarmente adatte a valori formattati e derivati, come nomi completi o etichette.

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);
    }
}

Corpi a espressione con condizioni

La singola espressione può includere un operatore condizionale (ternario), mantenendo la logica condizionale su una sola riga.

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);
    }
}

Metodi void con corpo a espressione

Anche un metodo che esegue un'azione e non restituisce nulla può avere un corpo a espressione, se l'azione consiste in una singola istruzione.

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");
    }
}

Costruttori con corpo a espressione

Anche un costruttore che esegue una sola assegnazione può usare la sintassi con freccia.

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);
    }
}

Quando NON usarla

I corpi a espressione sono riservati alle espressioni singole. Se servono più istruzioni, cicli o rami di convalida, usi invece un normale corpo a blocco.

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));
    }
}

Combinare più membri in una classe

Una classe piccola può usare la sintassi con freccia per quasi ogni membro, riducendo drasticamente il codice ripetitivo.

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");
    }
}

Mettere tutto insieme

Usi i membri con corpo a espressione per mantenere semplici getter, helper e metodi su una sola riga chiari e concisi, riservando i corpi a blocco alla logica vera e propria.

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);
    }
}

Verifica rapida

Verifichi la Sua comprensione dei membri con corpo a espressione.

Riepilogo

I membri con corpo a espressione usano => per definire un membro con una singola espressione. Funzionano con metodi, proprietà in sola lettura, singoli accessor get/set e persino costruttori. Li usi per scrivere istruzioni concise su una sola riga; passi a un corpo a blocco quando servono più istruzioni.

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);
    }
}

Domande Frequenti

La lezione «Membri con corpo a espressione» è gratuita?

Sì — il testo completo di «Membri con corpo a espressione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Membri con corpo a espressione»?

Scriva proprietà e metodi compatti. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Membri con corpo a espressione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Proprietà implementate automaticamente
  2. Proprietà complete con campi di supporto
  3. Membri con corpo a espressione
  4. Indexer
← Torna a C# Academy