C# Academy · Leçon

Membres dont le corps est une expression

Écrivez des propriétés et des méthodes compactes.

Membres dont le corps est une expression est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Une syntaxe plus concise

La syntaxe à expression unique utilise => pour définir un membre sous la forme d’une seule expression, en remplacement d’un corps complet { ... }. Elle rend les membres courts plus compacts et lisibles.

using System;

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

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

Méthodes à expression unique

Toute méthode dont le corps est constitué d’une seule expression peut utiliser =>. Le résultat de l’expression devient la valeur de retour.

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

Propriétés en lecture seule à expression unique

Une propriété calculée en lecture seule peut utiliser => au lieu de 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);
    }
}

Accesseurs get et set à expression unique

Vous pouvez également donner leur propre corps sous forme d’expression aux accesseurs get et set, ce qui est utile avec un champ de stockage.

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

Retour de chaînes calculées

Les propriétés à expression unique sont particulièrement adaptées aux valeurs dérivées et mises en forme, comme les noms complets ou les étiquettes.

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

Expressions uniques avec conditions

L’expression unique peut contenir un opérateur conditionnel ternaire, ce qui permet de conserver une logique de branchement sur une seule ligne.

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

Méthodes void à expression unique

Une méthode qui effectue une action, sans rien renvoyer, peut également utiliser une expression unique si l’action tient en une seule instruction.

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

Constructeurs à expression unique

Un constructeur qui ne contient qu’une affectation peut également utiliser la syntaxe fléchée.

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

Quand ne pas utiliser NOT

Les corps sous forme d’expression sont réservés aux expressions uniques. Si vous avez besoin de plusieurs instructions, de boucles ou de branches de validation, utilisez plutôt un corps de bloc classique.

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

Combinaison de plusieurs membres dans une classe

Une petite classe peut utiliser la syntaxe fléchée pour presque tous ses membres, ce qui réduit considérablement le code répétitif.

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

Mise en pratique

Utilisez les membres à expression unique pour garder les accesseurs get simples, les assistants et les méthodes d’une ligne propres, et réservez les corps de bloc à la logique réelle.

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

Vérification rapide

Vérifiez votre compréhension des membres à expression unique.

Récapitulatif

Les membres à expression unique utilisent => pour définir un membre avec une seule expression. Ils fonctionnent avec les méthodes, les propriétés en lecture seule, les accesseurs get/set individuels et même les constructeurs. Utilisez-les pour les instructions concises d’une ligne ; passez à un corps de bloc dès que plusieurs instructions sont nécessaires.

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

Questions Fréquemment Posées

La leçon « Membres dont le corps est une expression » est-elle gratuite ?

Oui — le texte complet de « Membres dont le corps est une expression » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Membres dont le corps est une expression » ?

Écrivez des propriétés et des méthodes compactes. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Membres dont le corps est une expression » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Propriétés implémentées automatiquement
Propriétés complètes avec champs de stockage
Membres dont le corps est une expression
Indexeurs

← Retour à C# Academy