C# Academy · Leçon

Encapsulation et désencapsulation

Comprenez le coût de la conversion vers object.

Encapsulation et désencapsulation 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 que l’encapsulation ?

L’encapsulation enveloppe un type valeur dans un objet afin qu’il puisse être traité comme un type référence. object o = 5; encapsule l’entier dans le tas.

using System;

class Program
{
    static void Main()
    {
        int n = 5;
        object o = n;   // boxing
        Console.WriteLine("Boxed value: " + o);
    }
}

Pourquoi l’encapsulation se produit

L’encapsulation se produit chaque fois qu’un type valeur est affecté à une variable de type object (ou à une interface). L’environnement d’exécution alloue une boîte dans le tas qui contient une copie de la valeur.

using System;

class Program
{
    static void Main()
    {
        double d = 3.14;
        object boxed = d;   // boxing copies d into a heap object
        Console.WriteLine(boxed);
    }
}

Qu’est-ce que la désencapsulation ?

La désencapsulation extrait le type valeur de la boîte au moyen d’une conversion explicite. Le type de conversion doit correspondre exactement au type encapsulé.

using System;

class Program
{
    static void Main()
    {
        object o = 42;        // boxing
        int n = (int)o;        // unboxing
        Console.WriteLine("Unboxed: " + n);
    }
}

La désencapsulation exige le bon type

Vous devez désencapsuler vers le type d’origine exact. Une désencapsulation vers un autre type déclenche InvalidCastException.

using System;

class Program
{
    static void Main()
    {
        object o = 100;
        try
        {
            long wrong = (long)o;   // InvalidCastException at runtime
            Console.WriteLine(wrong);
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("Must unbox to int, not long");
        }
    }
}

L’encapsulation crée une copie

L’encapsulation copie la valeur. Modifier l’original par la suite ne modifie pas la copie encapsulée.

using System;

class Program
{
    static void Main()
    {
        int n = 1;
        object o = n;   // box copies 1
        n = 99;
        Console.WriteLine("original=" + n + ", boxed=" + o);
    }
}

Le coût de l’encapsulation

Chaque boîte alloue de la mémoire dans le tas et augmente la pression sur le ramasse-miettes. Dans les boucles très sollicitées, cette surcharge peut réduire considérablement les performances.

using System;

class Program
{
    static void Main()
    {
        // Each iteration boxes an int -> many heap allocations
        object sumBox = 0;
        for (int i = 0; i < 5; i++)
        {
            int current = (int)sumBox + i;
            sumBox = current;   // box again
        }
        Console.WriteLine("Result: " + sumBox);
    }
}

Éviter l’encapsulation avec les génériques

Les collections génériques comme List<int> stockent les types valeur sans encapsulation, contrairement à l’ancienne collection non générique ArrayList.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var list = new List<int>();   // no boxing
        list.Add(1);
        list.Add(2);
        int first = list[0];           // no unboxing
        Console.WriteLine("First: " + first);
    }
}

Encapsulation avec les interfaces

Affecter une structure à une variable d’interface l’encapsule également, car la référence de l’interface doit pointer vers un objet du tas.

using System;

class Program
{
    static void Main()
    {
        int n = 7;
        IComparable c = n;   // boxing to interface
        Console.WriteLine(c.CompareTo(10));
    }
}

Détecter les types encapsulés

Vous pouvez vérifier le type d’un objet encapsulé lors de l’exécution avec is avant de le désencapsuler en toute sécurité.

using System;

class Program
{
    static void Main()
    {
        object o = 3.5;
        if (o is double d)
            Console.WriteLine("It is a double: " + d);
        else
            Console.WriteLine("Not a double");
    }
}

Encapsulation lors de la concaténation de chaînes

La concaténation d’un type valeur avec des chaînes peut l’encapsuler. L’interpolation ou ToString est souvent plus claire, même si l’encapsulation est généralement négligeable dans ce cas.

using System;

class Program
{
    static void Main()
    {
        int count = 3;
        string msg = "Count is " + count;   // count is converted
        Console.WriteLine(msg);
    }
}

Mise en pratique

L’encapsulation fait le lien entre les mondes des valeurs et des références, mais elle entraîne des allocations. Préférez les génériques pour l’éviter et désencapsulez vers le type exact après une vérification sûre.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        object boxed = 256;
        if (boxed is int value)
            Console.WriteLine("Safely unboxed: " + value);

        var noBox = new List<int> { 1, 2, 3 };
        Console.WriteLine("Generic count: " + noBox.Count);
    }
}

Vérification rapide

Vérifiez votre compréhension de l’encapsulation et de la désencapsulation.

Récapitulatif

L’encapsulation enveloppe un type valeur dans un objet du tas (par exemple object o = 5;) ; la désencapsulation l’extrait au moyen d’une conversion explicite vers le type d’origine exact. L’encapsulation copie la valeur et alloue de la mémoire, ce qui augmente la pression sur le ramasse-miettes. Préférez les collections génériques comme List<int> pour éviter l’encapsulation et utilisez is pour une désencapsulation sûre.

using System;

class Program
{
    static void Main()
    {
        object boxed = 42;     // box
        int n = (int)boxed;     // unbox
        Console.WriteLine(n);
    }
}

Questions Fréquemment Posées

La leçon « Encapsulation et désencapsulation » est-elle gratuite ?

Oui — le texte complet de « Encapsulation et désencapsulation » 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 « Encapsulation et désencapsulation » ?

Comprenez le coût de la conversion vers object. 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 « Encapsulation et désencapsulation » ?

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