Comprendre les modificateurs d'accès en C#

Introduction

Tim Corey commence par présenter les modificateurs d'accès, en expliquant qu'ils déterminent qui peut voir et utiliser une ressource en C#. Alors que nous sommes familiers avec les modificateurs publics et privés couramment utilisés, Tim explore six modificateurs d'accès différents et leurs cas d'utilisation.

Application démo expliquée

public class AccessDemo
{
    private void PrivateDemo() { }
    internal void InternalDemo() { }
    public void PublicDemo() { }
}

public class AccessDemo
{
    private void PrivateDemo() { }
    internal void InternalDemo() { }
    public void PublicDemo() { }
}

De quoi s'agit-il:

Le modificateur private restreint l'accès à la méthode, au champ ou à la propriété uniquement au sein de la classe dans laquelle il est défini.

Exemple de code:

public class AccessDemo
{
    private void PrivateDemo()
    {
        Console.WriteLine("Private method can only be accessed within this class.");
    }

    public void CallPrivateDemo()
    {
        PrivateDemo();  // Works because it's within the same class
    }
}

public class AccessDemo
{
    private void PrivateDemo()
    {
        Console.WriteLine("Private method can only be accessed within this class.");
    }

    public void CallPrivateDemo()
    {
        PrivateDemo();  // Works because it's within the same class
    }
}

Explication : La méthode PrivateDemo est accessible uniquement au sein de la classe AccessDemo. Dans la vidéo, Tim montre qu'il n'est pas possible d'y accéder depuis l'extérieur de la classe, même si d'autres classes se trouvent dans le même projet.

Bonne pratique : Utilisez private lorsque vous souhaitez restreindre l'accès au fonctionnement interne de votre classe, en veillant à ce qu'elle ne puisse pas être modifiée directement depuis d'autres parties de votre application.

De quoi s'agit-il:

Le modificateur interne permet d'accéder à la méthode ou à la propriété uniquement au sein du même assemblage (le projet). Cette notion est plus large que le modificateur d'accès privé, car elle inclut toutes les classes au sein d'un même projet.

Exemple de code:

public class AccessDemo
{
    internal void InternalDemo()
    {
        Console.WriteLine("Internal method is accessible within the same assembly.");
    }
}

public class AccessDemo
{
    internal void InternalDemo()
    {
        Console.WriteLine("Internal method is accessible within the same assembly.");
    }
}

Explication : La méthode InternalDemo peut être accédée par n'importe quelle classe au sein du même assemblage, mais pas depuis d'autres assemblages. Dans la vidéo, Tim montre qu'internal permet l'accès à l'intérieur d'un même projet, mais interdit l'accès depuis l'extérieur.

Bonne pratique : Utilisez internal pour les méthodes ou les propriétés destinées à être utilisées uniquement au sein de l'assemblage actuel, telles que les fonctions d'aide ou les utilitaires qui ne doivent pas être exposés à des projets externes.

De quoi s'agit-il:

Le modificateur public permet d'accéder à la méthode ou à la propriété à partir de n'importe quelle autre classe ou assemblée. Il s'agit du niveau d'accès le plus permissif.

Exemple de code:

public class AccessDemo
{
    public void PublicDemo()
    {
        Console.WriteLine("Public method can be accessed from any class.");
    }
}

public class AccessDemo
{
    public void PublicDemo()
    {
        Console.WriteLine("Public method can be accessed from any class.");
    }
}

Explication : La méthode PublicDemo est accessible depuis n'importe où, y compris d'autres classes dans le même assemblage ou d'autres assemblages. Tim démontre que public est le modificateur d'accès le plus courant, en particulier lors de l'exposition de méthodes dans des bibliothèques.

Bonne pratique : Utilisez public pour les méthodes et les propriétés qui doivent être accessibles à d'autres parties de l'application ou à des projets externes, tels que les points d'extrémité d'API ou les utilitaires largement utilisés.

De quoi s'agit-il:

Le modificateur protected permet d'accéder à la méthode ou à la propriété dans la classe où elle est définie, ainsi que dans toutes les classes dérivées (héritage). Ce modificateur est utile pour la programmation orientée objet, en particulier dans les cas d'héritage.

Exemple de code:

public class AccessDemo
{
    protected void ProtectedDemo()
    {
        Console.WriteLine("Protected method can be accessed within the class and derived classes.");
    }
}

public class DerivedClass : AccessDemo
{
    public void CallProtectedDemo()
    {
        ProtectedDemo();  // Accessible because of inheritance
    }
}

public class AccessDemo
{
    protected void ProtectedDemo()
    {
        Console.WriteLine("Protected method can be accessed within the class and derived classes.");
    }
}

public class DerivedClass : AccessDemo
{
    public void CallProtectedDemo()
    {
        ProtectedDemo();  // Accessible because of inheritance
    }
}

Explication : La méthode ProtectedDemo peut être accédée depuis la classe AccessDemo et par toute classe qui en hérite. Tim explique que protected est moins courant mais très utile lorsqu'on travaille avec l'héritage.

Bonne pratique : Utilisez protected lorsque vous souhaitez permettre aux classes dérivées d'accéder à des méthodes ou à des propriétés spécifiques, mais que vous ne souhaitez pas qu'elles soient accessibles en dehors de la hiérarchie de la classe.

De quoi s'agit-il:

Le modificateur private protected combine les règles de private et de protected. Il restreint l'accès aux méthodes ou aux propriétés au sein de la classe de définition et des classes dérivées dans le même assemblage. Cela signifie qu'il offre un niveau de protection supplémentaire et des limites plus strictes pour le contrôle d'accès basé sur l'héritage par rapport à protected.

Exemple de code:

public class AccessDemo
{
    private protected void PrivateProtectedDemo()
    {
        Console.WriteLine("Private Protected method can be accessed within the same assembly and derived classes.");
    }
}

public class DerivedClass : AccessDemo
{
    public void CallPrivateProtectedDemo()
    {
        PrivateProtectedDemo();  // Accessible because of inheritance within the same assembly
    }
}

public class UnrelatedClass
{
    public void TestAccess()
    {
        // PrivateProtectedDemo();  // Error: Not accessible in unrelated classes
    }
}

public class AccessDemo
{
    private protected void PrivateProtectedDemo()
    {
        Console.WriteLine("Private Protected method can be accessed within the same assembly and derived classes.");
    }
}

public class DerivedClass : AccessDemo
{
    public void CallPrivateProtectedDemo()
    {
        PrivateProtectedDemo();  // Accessible because of inheritance within the same assembly
    }
}

public class UnrelatedClass
{
    public void TestAccess()
    {
        // PrivateProtectedDemo();  // Error: Not accessible in unrelated classes
    }
}

Explication : La méthode PrivateProtectedDemo est accessible dans DerivedClass car elle hérite de AccessDemo et existe dans le même assemblage. Cependant, elle ne peut pas être accédée dans UnrelatedClass, car cette classe n'hérite pas de AccessDemo.

Bonne pratique : Utilisez le modificateur d'accès private protected avec parcimonie lorsque vous devez contrôler étroitement l'accès à l'héritage au sein d'un même assemblage. Ces outils sont particulièrement utiles dans les scénarios où l'exposition de méthodes ou de propriétés à travers des assemblages pourrait compromettre l'encapsulation.

De quoi s'agit-il:

Le modificateur interne protégé combine les niveaux de modificateurs d'accès protégé et interne. Il permet l'accès à partir du même assemblage ou de classes dérivées, même si elles se trouvent dans un autre assemblage.

Exemple de code:

public class AccessDemo
{
    protected internal void ProtectedInternalDemo()
    {
        Console.WriteLine("Protected Internal method can be accessed within the same assembly or from derived classes.");
    }
}

public class DerivedClass : AccessDemo
{
    public void CallProtectedInternalDemo()
    {
        ProtectedInternalDemo();  // Accessible due to inheritance
    }
}

public class AccessDemo
{
    protected internal void ProtectedInternalDemo()
    {
        Console.WriteLine("Protected Internal method can be accessed within the same assembly or from derived classes.");
    }
}

public class DerivedClass : AccessDemo
{
    public void CallProtectedInternalDemo()
    {
        ProtectedInternalDemo();  // Accessible due to inheritance
    }
}

Explication : La méthode ProtectedInternalDemo est accessible au sein du même assemblage, et aussi depuis toute classe dérivée, quel que soit l'assemblage.

Bonne pratique : Utilisez protected internal lorsque vous souhaitez exposer une méthode à la fois aux classes dérivées (dans d'autres assemblages) et aux classes du même assemblage, mais pas à tout le monde.

1. Protéger les informations privées

Tim explique pourquoi les informations sensibles, telles que les numéros de sécurité sociale (SSN) ou les numéros de carte de crédit, ne doivent pas être rendues publiques. Il présente un exemple de "mauvaise classe" où les données sont exposées en raison de l'accès public :

Mauvais exemple:

public class User
{
    public string SSN; // Anyone can access and modify it directly
}

public class User
{
    public string SSN; // Anyone can access and modify it directly
}

Bon exemple:

public class User
{
    private string ssn;

    public string GetMaskedSSN()
    {
        return "XXX-XX-" + ssn.Substring(ssn.Length - 4);
    }

    public void SetSSN(string value)
    {
        // Add validation if needed
        ssn = value;
    }
}

public class User
{
    private string ssn;

    public string GetMaskedSSN()
    {
        return "XXX-XX-" + ssn.Substring(ssn.Length - 4);
    }

    public void SetSSN(string value)
    {
        // Add validation if needed
        ssn = value;
    }
}

2. sécuriser les méthodes privées

Début de la traduction : 35:11\ Tim explique que les méthodes privées permettent d'encapsuler des comportements qui ne doivent pas être directement accessibles. Il utilise l'exemple d'une méthode DeleteUser comme partie d'un processus plus large comme le départ d'un employé.

Mauvais exemple:

public class UserManager
{
    public void DeleteUser(int userId)
    {
        // Deletes the user without considering related processes
    }
}

public class UserManager
{
    public void DeleteUser(int userId)
    {
        // Deletes the user without considering related processes
    }
}

Bon exemple:

public class UserManager
{
    public void OffboardUser(int userId)
    {
        RevokeAccess(userId);
        DeleteUser(userId); // Used privately as part of offboarding
    }

    private void DeleteUser(int userId)
    {
        // Internal logic to delete the user
    }

    private void RevokeAccess(int userId)
    {
        // Logic to revoke system access
    }
}

public class UserManager
{
    public void OffboardUser(int userId)
    {
        RevokeAccess(userId);
        DeleteUser(userId); // Used privately as part of offboarding
    }

    private void DeleteUser(int userId)
    {
        // Internal logic to delete the user
    }

    private void RevokeAccess(int userId)
    {
        // Logic to revoke system access
    }
}

3. prévenir les bogues

Les modificateurs d'accès permettent d'éviter les bogues en garantissant que les données sont définies ou récupérées avec une validation appropriée. Tim illustre cela avec un exemple impliquant une propriété Age.

Mauvais exemple:

public class Person
{
    public int Age; // Can be directly set to an invalid value
}

public class Person
{
    public int Age; // Can be directly set to an invalid value
}

Bon exemple:

public class Person
{
    private int age;

    public int Age
    {
        get { return age; }
        set
        {
            if (value < 0 || value > 120)
                throw new ArgumentOutOfRangeException("Age must be between 0 and 120.");
            age = value;
        }
    }
}

public class Person
{
    private int age;

    public int Age
    {
        get { return age; }
        set
        {
            if (value < 0 || value > 120)
                throw new ArgumentOutOfRangeException("Age must be between 0 and 120.");
            age = value;
        }
    }
}

<Réduire les confusions et améliorer la clarté

L'utilisation correcte des modificateurs d'accès simplifie le développement en n'exposant que ce qui est nécessaire, évitant ainsi toute confusion. Par exemple, dans une application comportant des milliers de méthodes, le fait de n'exposer que les méthodes publiques permet aux développeurs de ne voir que les options pertinentes.

Exemple :

public class MathLibrary
{
    public int Add(int a, int b) => a + b;
    public int Subtract(int a, int b) => a - b;

    private void LogCalculation(string operation, int result)
    {
        // Logging is internal and not exposed
    }
}

public class MathLibrary
{
    public int Add(int a, int b) => a + b;
    public int Subtract(int a, int b) => a - b;

    private void LogCalculation(string operation, int result)
    {
        // Logging is internal and not exposed
    }
}

5. Avantages pour les grandes applications ou bibliothèques

Pour les projets de grande envergure, Tim explique comment l'utilisation correcte des modificateurs d'accès garantit que seules les parties requises d'une bibliothèque sont exposées, réduisant ainsi la charge cognitive des développeurs qui utilisent la bibliothèque.

Exemple :

public class MathLibrary
{
    public int Add(int a, int b) => a + b;
    public int Subtract(int a, int b) => a - b;

    private void LogCalculation(string operation, int result)
    {
        // Logging is internal and not exposed
    }
}

public class MathLibrary
{
    public int Add(int a, int b) => a + b;
    public int Subtract(int a, int b) => a - b;

    private void LogCalculation(string operation, int result)
    {
        // Logging is internal and not exposed
    }
}

En utilisant correctement ces modificateurs d'accès, vous facilitez votre travail et celui de votre interlocuteur.