Membres à corps d'expression

Fait partie de la section Programmation Orientée Objet du Journey C# de Coddy. Leçon 14 sur 70.

Les membres à corps d’expression offrent une syntaxe concise pour les membres qui ne contiennent qu’une seule expression. Au lieu d’écrire le corps complet des méthodes ou des propriétés avec des accolades, vous utilisez la syntaxe fléchée =>.

Pour les méthodes qui renvoient une seule expression, vous pouvez remplacer le corps entier :

// Méthode traditionnelle
public int Add(int a, int b)
{
    return a + b;
}

// Méthode expression-bodied
public int Add(int a, int b) => a + b;

Cette syntaxe fonctionne également pour les propriétés en lecture seule, que tu as déjà brièvement rencontrées :

public class Circle
{
    public double Radius { get; set; }
    public double Area => Math.PI * Radius * Radius;
    public double Circumference => 2 * Math.PI * Radius;
}

Vous pouvez également utiliser des corps d’expression pour les accesseurs get et set des propriétés individuellement :

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

Même les constructeurs peuvent utiliser cette syntaxe lorsqu’ils contiennent une seule instruction :

public class Person
{
    public string Name { get; }
    public Person(string name) => Name = name;
}

Les membres à expression rendent votre code plus lisible lorsque la logique est simple. Utilisez-les pour les opérations simples, mais conservez les corps traditionnels lorsque vous avez besoin de plusieurs instructions ou d’une logique complexe.

Défi

Facile

Construisons un calculateur de prix de produits qui met en valeur la puissance des membres à corps d’expression pour écrire un code propre et concis.

Vous allez créer deux fichiers pour organiser votre code :

Product.cs : définissez une classe Product dans l’espace de noms Store. Cette classe doit présenter différents membres à corps d’expression :
- Une propriété implémentée automatiquement Name (string) et BasePrice (decimal)
- Un constructeur à corps d’expression qui définit les deux propriétés
- Une propriété en lecture seule à corps d’expression TaxAmount qui calcule 10 % du prix de base
- Une propriété en lecture seule à corps d’expression TotalPrice qui renvoie le prix de base augmenté du montant de la taxe
- Une méthode à corps d’expression GetDiscount(decimal percentage) qui renvoie le montant de la remise (prix de base multiplié par le pourcentage, puis divisé par 100)
- Une méthode à corps d’expression GetFinalPrice(decimal discountPercentage) qui renvoie le prix total diminué de la remise
Program.cs : dans votre fichier principal, créez un Product à l’aide de valeurs saisies, puis affichez le détail de son prix.

Vous recevrez trois entrées :

Nom du produit
Prix de base
Pourcentage de remise à appliquer

Affichez les détails du prix dans ce format :

Product: {Name}
Base Price: {BasePrice}
Tax (10%): {TaxAmount}
Total Price: {TotalPrice}
Discount ({percentage}%): {discountAmount}
Final Price: {finalPrice}

Par exemple, si les entrées sont Laptop, 1000 et 15, la sortie doit être :

Product: Laptop
Base Price: 1000.00
Tax (10%): 100.00
Total Price: 1100.00
Discount (15%): 150.00
Final Price: 950.00

Formatez chaque valeur monétaire avec exactement deux décimales, par exemple value.ToString("F2") ou $"{value:F2}". Cela s’applique de la même manière au prix de base, à la taxe, au total, à la remise et au prix final.

N’oubliez pas d’utiliser la syntaxe fléchée => pour tous les membres qui contiennent une seule expression. Votre code restera ainsi propre et lisible !

Essayez vous-même

using System;
using Store;

class Program
{
    public static void Main(string[] args)
    {
        // Lire les entrées
        string name = Console.ReadLine();
        decimal basePrice = Convert.ToDecimal(Console.ReadLine());
        decimal discountPercentage = Convert.ToDecimal(Console.ReadLine());

        // Créer un objet Product en utilisant les valeurs d'entrée
        Product product = new Product(name, basePrice);

        // Calculer le montant de la remise en utilisant la méthode GetDiscount
        decimal discountAmount = product.GetDiscount(discountPercentage);

        // Calculer le prix final en utilisant la méthode GetFinalPrice
        decimal finalPrice = product.GetFinalPrice(discountPercentage);

        // Afficher les détails de tarification dans le format requis :
        Console.WriteLine($"Product: {product.Name}");
        Console.WriteLine($"Base Price: {product.BasePrice:F2}");
        Console.WriteLine($"Tax (10%): {product.TaxAmount:F2}");
        Console.WriteLine($"Total Price: {product.TotalPrice:F2}");
        Console.WriteLine($"Discount ({discountPercentage}%): {discountAmount:F2}");
        Console.WriteLine($"Final Price: {finalPrice:F2}");
    }
}