0Pricing
C# Academy · Leçon

Conception statique ou par instance

Déterminez quand un état statique est approprié.

Conception statique ou par instance est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Un choix de conception

Choisir entre statique et instance est un choix de conception. La question essentielle est la suivante : le comportement dépend-il de l'état propre à chaque objet, ou uniquement de ses entrées ?

using System;

class Program
{
    // Depends only on inputs -> good static method
    static int Max(int a, int b) => a > b ? a : b;

    static void Main()
    {
        Console.WriteLine(Max(3, 8));
    }
}

Utiliser le statique pour la logique sans état

Si une méthode n'a besoin d'aucun champ d'instance et se contente de transformer des entrées, rendez-la static. Les fonctions mathématiques utilitaires et les formateurs en sont de parfaits exemples.

using System;

static class Convert2
{
    public static double MilesToKm(double miles) => miles * 1.60934;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Convert2.MilesToKm(10).ToString("0.0") + " km");
    }
}

Utiliser une instance pour l'état

Si le comportement dépend de données qui varient selon l'objet, utilisez une instance. Chaque objet possède son propre état.

using System;

class Counter
{
    private int _count;
    public void Increment() => _count++;
    public int Value => _count;
}

class Program
{
    static void Main()
    {
        var a = new Counter();
        var b = new Counter();
        a.Increment();
        a.Increment();
        b.Increment();
        Console.WriteLine("a=" + a.Value + ", b=" + b.Value);
    }
}

L'état partagé est un état global

Un champ statique est en pratique global. Il peut provoquer des erreurs subtiles lorsque de nombreuses parties d'un programme le lisent et le modifient. Préférez l'état d'instance lorsque chaque utilisateur a besoin de sa propre copie.

using System;

class BadCart
{
    public static int Items;   // shared by EVERYONE -> usually wrong for a cart
}

class Program
{
    static void Main()
    {
        BadCart.Items++;
        BadCart.Items++;
        Console.WriteLine("All carts share: " + BadCart.Items);
    }
}

Testabilité

Les méthodes statiques pures sont faciles à tester : même entrée, même sortie. En revanche, l'état statique modifiable se propage d'un test à l'autre et les rend fragiles.

using System;

static class Calc
{
    public static int Add(int a, int b) => a + b;   // trivially testable
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Calc.Add(2, 2) == 4 ? "pass" : "fail");
    }
}

Le statique pour les méthodes de fabrique

Les méthodes de fabrique statiques sont un moyen clair de créer des instances configurées avec un nom explicite.

using System;

class Color
{
    public int R, G, B;
    private Color(int r, int g, int b) { R = r; G = g; B = b; }

    public static Color Red() => new Color(255, 0, 0);
    public static Color White() => new Color(255, 255, 255);
}

class Program
{
    static void Main()
    {
        var c = Color.Red();
        Console.WriteLine(c.R + "," + c.G + "," + c.B);
    }
}

Éviter le statique simplement pour éviter de créer des objets

Ne rendez pas tout statique uniquement pour éviter de créer des objets. Si un type représente une chose dotée d'un état, les instances maintiennent cet état isolé et sûr.

using System;

class Player
{
    public string Name;
    public int Health = 100;
    public void TakeDamage(int d) => Health -= d;
}

class Program
{
    static void Main()
    {
        var p1 = new Player { Name = "A" };
        var p2 = new Player { Name = "B" };
        p1.TakeDamage(30);
        Console.WriteLine(p1.Name + ": " + p1.Health + ", " + p2.Name + ": " + p2.Health);
    }
}

Combiner les deux de manière appropriée

De nombreuses classes utilisent des membres statiques pour les constantes ou les compteurs partagés, et des membres d'instance pour les données propres à chaque objet. Cette combinaison est parfaitement idiomatique.

using System;

class Invoice
{
    private static int _seq = 1000;
    public readonly int Number;
    public decimal Amount;

    public Invoice(decimal amount)
    {
        Number = _seq++;
        Amount = amount;
    }
}

class Program
{
    static void Main()
    {
        var i1 = new Invoice(50m);
        var i2 = new Invoice(75m);
        Console.WriteLine(i1.Number + " / " + i2.Number);
    }
}

Problème de concurrence

Un état statique partagé peut être consulté simultanément par plusieurs threads, ce qui risque de provoquer des conditions de concurrence. Un état d'instance confiné à un seul thread est plus sûr par défaut.

using System;

class SafeCalc
{
    // No shared mutable state -> naturally thread-safe
    public static long Factorial(int n)
    {
        long result = 1;
        for (int i = 2; i <= n; i++) result *= i;
        return result;
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(SafeCalc.Factorial(5));
    }
}

Une règle simple

Statique = comportement appartenant au type et n'utilisant aucun état propre à un objet. Instance = comportement qui lit ou modifie un objet précis. En cas de doute, préférez une instance pour tout ce qui possède un état.

using System;

class Temperature
{
    public double Celsius;                                  // instance state
    public static double ToF(double c) => c * 9 / 5 + 32;   // stateless helper
}

class Program
{
    static void Main()
    {
        var t = new Temperature { Celsius = 30 };
        Console.WriteLine(Temperature.ToF(t.Celsius));
    }
}

Mise en pratique

Une bonne conception sépare les fonctions utilitaires sans état (statiques) des modèles avec état (d'instance), en limitant volontairement l'état mutable partagé.

using System;

static class TaxRules
{
    public static decimal Apply(decimal amount, decimal rate) => amount + amount * rate;
}

class Sale
{
    public decimal Subtotal;
    public decimal Total(decimal rate) => TaxRules.Apply(Subtotal, rate);
}

class Program
{
    static void Main()
    {
        var s = new Sale { Subtotal = 100m };
        Console.WriteLine(s.Total(0.2m));
    }
}

Vérification rapide

Vérifiez votre compréhension de la conception statique par rapport à la conception par instance.

Récapitulatif

Choisissez le statique pour une logique sans état qui dépend uniquement des entrées (fonctions utilitaires, fabriques, constantes), et l'instance pour un comportement lié à l'état propre à chaque objet. L'état statique modifiable est en pratique global, plus difficile à tester et susceptible de provoquer des erreurs de concurrence ; limitez-le donc au strict nécessaire et utilisez-le délibérément.

using System;

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

class Box { public int Size; public int Area() => Util.Sq(Size); }

class Program
{
    static void Main()
    {
        var box = new Box { Size = 4 };
        Console.WriteLine(box.Area());
    }
}

Questions Fréquemment Posées

La leçon « Conception statique ou par instance » est-elle gratuite ?

Oui — le texte complet de « Conception statique ou par instance » 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 « Conception statique ou par instance » ?

Déterminez quand un état statique est approprié. 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 4 sur 4.

Combien de temps prend la leçon « Conception statique ou par instance » ?

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

  1. Méthodes et champs statiques
  2. Classes statiques pour les utilitaires
  3. Constantes et champs readonly
  4. Conception statique ou par instance
← Retour à C# Academy