C# Academy · Leçon

Classes statiques pour les utilitaires

Regroupez les fonctions auxiliaires dans des classes statiques.

Classes statiques pour les utilitaires est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Qu’est-ce qu’une classe statique ?

Une classe statique est déclarée avec static class. Elle peut contenir uniquement des membres statiques et ne peut pas être instanciée. C’est l’emplacement naturel des fonctions utilitaires.

using System;

static class StringUtils
{
    public static string Shout(string s) => s.ToUpper() + "!";
}

class Program
{
    static void Main()
    {
        Console.WriteLine(StringUtils.Shout("hello"));
    }
}

Impossible de créer des instances

Vous n’écrivez jamais new pour une classe statique. Tous les accès passent directement par le nom de la classe.

using System;

static class MathUtils
{
    public static int Cube(int x) => x * x * x;
}

class Program
{
    static void Main()
    {
        // No instance needed
        Console.WriteLine(MathUtils.Cube(3));
    }
}

Seuls les membres statiques sont autorisés

Le compilateur impose que chaque membre d’une classe statique soit statique. Les champs d’instance et les constructeurs ne sont pas autorisés.

using System;

static class Temperature
{
    public static double ToFahrenheit(double c) => c * 9 / 5 + 32;
    public static double ToCelsius(double f) => (f - 32) * 5 / 9;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Temperature.ToFahrenheit(100));
        Console.WriteLine(Temperature.ToCelsius(32));
    }
}

Regrouper les méthodes utilitaires associées

Une classe statique regroupe les fonctions qui partagent un même thème et leur fournit un espace de noms clair, comme Validation.IsEmail(...).

using System;

static class Validation
{
    public static bool IsPositive(int n) => n > 0;
    public static bool IsEmail(string s) => s.Contains("@") && s.Contains(".");
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Validation.IsPositive(5));
        Console.WriteLine(Validation.IsEmail("a@b.com"));
    }
}

La classe Math intégrée

La classe Math de .NET est une classe statique. Vous ne l’instanciez jamais ; vous appelez simplement Math.Sqrt, Math.Max, etc.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(Math.Max(3, 9));
        Console.WriteLine(Math.Sqrt(144));
        Console.WriteLine(Math.Round(3.14159, 2));
    }
}

Classe statique avec champs statiques

Une classe statique peut contenir des champs statiques pour les constantes partagées ou la configuration utilisée par ses méthodes.

using System;

static class Pricing
{
    public static decimal Tax = 0.08m;

    public static decimal WithTax(decimal price) => price + price * Tax;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Pricing.WithTax(100m));
    }
}

Fonctions pures

Les méthodes utilitaires sont idéalement des fonctions pures : leur résultat dépend uniquement de leurs entrées, sans état caché. Elles sont ainsi prévisibles et faciles à tester.

using System;

static class Geometry
{
    public static double RectArea(double w, double h) => w * h;
    public static double TriArea(double b, double h) => 0.5 * b * h;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Geometry.RectArea(4, 5));
        Console.WriteLine(Geometry.TriArea(6, 3));
    }
}

Composer des méthodes utilitaires

Les méthodes utilitaires statiques peuvent s’appeler entre elles et construire des opérations plus complexes à partir d’opérations plus simples.

using System;

static class TextUtils
{
    public static string Clean(string s) => s.Trim().ToLower();
    public static string Slug(string s) => Clean(s).Replace(" ", "-");
}

class Program
{
    static void Main()
    {
        Console.WriteLine(TextUtils.Slug("  Hello World  "));
    }
}

Classe statique ou membres statiques dans une classe normale

Si un type ne contient que des méthodes utilitaires, rendez toute la classe statique. S’il combine des méthodes utilitaires et des instances, conservez une classe normale avec quelques membres statiques.

using System;

static class Convert2
{
    public static int FeetToInches(int feet) => feet * 12;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Convert2.FeetToInches(3) + " inches");
    }
}

Garder les utilitaires faciles à trouver

Regroupez les méthodes utilitaires dans des classes statiques bien nommées (DateUtils, StringUtils) afin que les autres développeurs puissent les trouver facilement.

using System;

static class DateUtils
{
    public static bool IsWeekend(DayOfWeek d) =>
        d == DayOfWeek.Saturday || d == DayOfWeek.Sunday;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(DateUtils.IsWeekend(DayOfWeek.Sunday));
        Console.WriteLine(DateUtils.IsWeekend(DayOfWeek.Monday));
    }
}

Mise en pratique

Les classes utilitaires statiques centralisent la logique sans état derrière un nom clair et réduisent la duplication dans votre base de code.

using System;

static class MoneyUtils
{
    public static string Format(decimal amount) => "$" + amount.ToString("0.00");
    public static decimal ApplyDiscount(decimal price, double pct) =>
        price * (decimal)(1 - pct / 100);
}

class Program
{
    static void Main()
    {
        decimal discounted = MoneyUtils.ApplyDiscount(80m, 25);
        Console.WriteLine(MoneyUtils.Format(discounted));
    }
}

Vérification rapide

Testez votre compréhension des classes statiques.

Récapitulatif

Une classe statique (static class X) ne peut pas être instanciée et peut contenir uniquement des membres statiques. Elle constitue l’emplacement habituel des fonctions utilitaires et des constantes sans état, regroupées sous un nom descriptif. La classe Math intégrée en est un exemple bien connu.

using System;

static class Util
{
    public static int Double(int n) => n * 2;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Util.Double(21));
    }
}

Questions Fréquemment Posées

La leçon « Classes statiques pour les utilitaires » est-elle gratuite ?

Oui — le texte complet de « Classes statiques pour les utilitaires » 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 « Classes statiques pour les utilitaires » ?

Regroupez les fonctions auxiliaires dans des classes statiques. 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 2 sur 4.

Combien de temps prend la leçon « Classes statiques pour les utilitaires » ?

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

← Retour à C# Academy