Apprendre le C#

Comprendre les modificateurs d'accès en C#

Tim Corey

46m 57s

Dans cet article, nous allons nous plonger dans les modificateurs d'accès C#, qui définissent la visibilité et l'accessibilité des types, des méthodes et des variables en C#. Tim Corey, dans sa vidéo "Modificateurs d'accès C# (au-delà de public et private) - ce qu'ils sont, comment les utiliser et les meilleures pratiques", explique les différents modificateurs d'accès et démontre leur utilisation pratique dans une application console.

Cet article explique ce que Tim couvre, avec des exemples de code pour améliorer votre compréhension. Les horodatages fournis vous permettent de suivre la vidéo pour une expérience plus pratique.

Qu'est-ce qu'un modificateur d'accès ?

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

Tim met en place une application simple pour démontrer le fonctionnement des différents modificateurs d'accès. L'application se compose d'une interface utilisateur en mode console et d'une bibliothèque de démonstration, toutes deux dans le cadre .NET.

Structure du projet:

Console UI : Une application console pour tester les modificateurs d'accès.
Bibliothèque de démonstration : Une bibliothèque de classes dans laquelle différents modificateurs d'accès sont présentés.

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

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

Public Class AccessDemo
    Private Sub PrivateDemo()
    End Sub

    Friend Sub InternalDemo()
    End Sub

    Public Sub PublicDemo()
    End Sub
End Class

Public Class AccessDemo
    Private Sub PrivateDemo()
    End Sub

    Friend Sub InternalDemo()
    End Sub

    Public Sub PublicDemo()
    End Sub
End Class

1. Privé

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
    }
}

Public Class AccessDemo
    Private Sub PrivateDemo()
        Console.WriteLine("Private method can only be accessed within this class.")
    End Sub

    Public Sub CallPrivateDemo()
        PrivateDemo()  ' Works because it's within the same class
    End Sub
End Class

Public Class AccessDemo
    Private Sub PrivateDemo()
        Console.WriteLine("Private method can only be accessed within this class.")
    End Sub

    Public Sub CallPrivateDemo()
        PrivateDemo()  ' Works because it's within the same class
    End Sub
End Class

Explication : La méthode PrivateDemo est uniquement accessible 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.

2. interne

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.");
    }
}

Public Class AccessDemo
    Friend Sub InternalDemo()
        Console.WriteLine("Internal method is accessible within the same assembly.")
    End Sub
End Class

Public Class AccessDemo
    Friend Sub InternalDemo()
        Console.WriteLine("Internal method is accessible within the same assembly.")
    End Sub
End Class

Explication : La méthode InternalDemo peut être accédée par n'importe quelle classe au sein du même assembly, mais pas depuis d'autres assemblies. 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.

3. public

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.");
    }
}

Public Class AccessDemo
    Public Sub PublicDemo()
        Console.WriteLine("Public method can be accessed from any class.")
    End Sub
End Class

Public Class AccessDemo
    Public Sub PublicDemo()
        Console.WriteLine("Public method can be accessed from any class.")
    End Sub
End Class

Explication : La méthode PublicDemo est accessible depuis n'importe où, y compris d'autres classes dans le même assembly ou d'autres assemblies. 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.

4. protégé

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
    }
}

Public Class AccessDemo
    Protected Sub ProtectedDemo()
        Console.WriteLine("Protected method can be accessed within the class and derived classes.")
    End Sub
End Class

Public Class DerivedClass
    Inherits AccessDemo

    Public Sub CallProtectedDemo()
        ProtectedDemo()  ' Accessible because of inheritance
    End Sub
End Class

Public Class AccessDemo
    Protected Sub ProtectedDemo()
        Console.WriteLine("Protected method can be accessed within the class and derived classes.")
    End Sub
End Class

Public Class DerivedClass
    Inherits AccessDemo

    Public Sub CallProtectedDemo()
        ProtectedDemo()  ' Accessible because of inheritance
    End Sub
End Class

Explication : La méthode ProtectedDemo peut être accédée depuis la classe AccessDemo et toute classe qui hérite de celle-ci. 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.

5. Privé Protégé

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
    }
}

Public Class AccessDemo
    Private Protected Sub PrivateProtectedDemo()
        Console.WriteLine("Private Protected method can be accessed within the same assembly and derived classes.")
    End Sub
End Class

Public Class DerivedClass
    Inherits AccessDemo

    Public Sub CallPrivateProtectedDemo()
        PrivateProtectedDemo()  ' Accessible because of inheritance within the same assembly
    End Sub
End Class

Public Class UnrelatedClass
    Public Sub TestAccess()
        ' PrivateProtectedDemo()  ' Error: Not accessible in unrelated classes
    End Sub
End Class

Public Class AccessDemo
    Private Protected Sub PrivateProtectedDemo()
        Console.WriteLine("Private Protected method can be accessed within the same assembly and derived classes.")
    End Sub
End Class

Public Class DerivedClass
    Inherits AccessDemo

    Public Sub CallPrivateProtectedDemo()
        PrivateProtectedDemo()  ' Accessible because of inheritance within the same assembly
    End Sub
End Class

Public Class UnrelatedClass
    Public Sub TestAccess()
        ' PrivateProtectedDemo()  ' Error: Not accessible in unrelated classes
    End Sub
End Class

Explication : La méthode PrivateProtectedDemo est accessible dans le DerivedClass car il hérite de AccessDemo et existe dans le même assembly. 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.

6. interne protégé

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
    }
}

Public Class AccessDemo
    Protected Friend Sub ProtectedInternalDemo()
        Console.WriteLine("Protected Internal method can be accessed within the same assembly or from derived classes.")
    End Sub
End Class

Public Class DerivedClass
    Inherits AccessDemo

    Public Sub CallProtectedInternalDemo()
        ProtectedInternalDemo()  ' Accessible due to inheritance
    End Sub
End Class

Public Class AccessDemo
    Protected Friend Sub ProtectedInternalDemo()
        Console.WriteLine("Protected Internal method can be accessed within the same assembly or from derived classes.")
    End Sub
End Class

Public Class DerivedClass
    Inherits AccessDemo

    Public Sub CallProtectedInternalDemo()
        ProtectedInternalDemo()  ' Accessible due to inheritance
    End Sub
End Class

Explication : La méthode ProtectedInternalDemo est accessible au sein du même assembly et aussi depuis toute classe dérivée, indépendamment de l'assembly.

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.

Pourquoi ne pas tout rendre public?

Tim Corey explique l'importance de l'utilisation des modificateurs d'accès et pourquoi tout ne devrait pas être public. Si tout rendre public peut sembler pratique, cela introduit des risques importants, notamment des violations de données, des bogues et des confusions dans le développement. Les modificateurs d'accès existent pour sécuriser les informations, empêcher un accès public involontaire et apporter de la clarté dans les bases de code.

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
}

Public Class User
    Public SSN As String ' Anyone can access and modify it directly
End Class

Public Class User
    Public SSN As String ' Anyone can access and modify it directly
End Class

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;
    }
}

Public Class User
    Private ssn As String

    Public Function GetMaskedSSN() As String
        Return "XXX-XX-" & ssn.Substring(ssn.Length - 4)
    End Function

    Public Sub SetSSN(value As String)
        ' Add validation if needed
        ssn = value
    End Sub
End Class

Public Class User
    Private ssn As String

    Public Function GetMaskedSSN() As String
        Return "XXX-XX-" & ssn.Substring(ssn.Length - 4)
    End Function

    Public Sub SetSSN(value As String)
        ' Add validation if needed
        ssn = value
    End Sub
End Class

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 dans le cadre 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
    }
}

Public Class UserManager
    Public Sub DeleteUser(userId As Integer)
        ' Deletes the user without considering related processes
    End Sub
End Class

Public Class UserManager
    Public Sub DeleteUser(userId As Integer)
        ' Deletes the user without considering related processes
    End Sub
End Class

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
    }
}

Public Class UserManager
    Public Sub OffboardUser(userId As Integer)
        RevokeAccess(userId)
        DeleteUser(userId) ' Used privately as part of offboarding
    End Sub

    Private Sub DeleteUser(userId As Integer)
        ' Internal logic to delete the user
    End Sub

    Private Sub RevokeAccess(userId As Integer)
        ' Logic to revoke system access
    End Sub
End Class

Public Class UserManager
    Public Sub OffboardUser(userId As Integer)
        RevokeAccess(userId)
        DeleteUser(userId) ' Used privately as part of offboarding
    End Sub

    Private Sub DeleteUser(userId As Integer)
        ' Internal logic to delete the user
    End Sub

    Private Sub RevokeAccess(userId As Integer)
        ' Logic to revoke system access
    End Sub
End Class

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
}

Public Class Person
    Public Age As Integer ' Can be directly set to an invalid value
End Class

Public Class Person
    Public Age As Integer ' Can be directly set to an invalid value
End Class

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;
        }
    }
}

Public Class Person
    Private _age As Integer

    Public Property Age As Integer
        Get
            Return _age
        End Get
        Set(value As Integer)
            If value < 0 OrElse value > 120 Then
                Throw New ArgumentOutOfRangeException("Age must be between 0 and 120.")
            End If
            _age = value
        End Set
    End Property
End Class

Public Class Person
    Private _age As Integer

    Public Property Age As Integer
        Get
            Return _age
        End Get
        Set(value As Integer)
            If value < 0 OrElse value > 120 Then
                Throw New ArgumentOutOfRangeException("Age must be between 0 and 120.")
            End If
            _age = value
        End Set
    End Property
End Class

4. 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
    }
}

Public Class MathLibrary
    Public Function Add(a As Integer, b As Integer) As Integer
        Return a + b
    End Function

    Public Function Subtract(a As Integer, b As Integer) As Integer
        Return a - b
    End Function

    Private Sub LogCalculation(operation As String, result As Integer)
        ' Logging is internal and not exposed
    End Sub
End Class

Public Class MathLibrary
    Public Function Add(a As Integer, b As Integer) As Integer
        Return a + b
    End Function

    Public Function Subtract(a As Integer, b As Integer) As Integer
        Return a - b
    End Function

    Private Sub LogCalculation(operation As String, result As Integer)
        ' Logging is internal and not exposed
    End Sub
End Class

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
    }
}

Public Class MathLibrary
    Public Function Add(a As Integer, b As Integer) As Integer
        Return a + b
    End Function

    Public Function Subtract(a As Integer, b As Integer) As Integer
        Return a - b
    End Function

    Private Sub LogCalculation(operation As String, result As Integer)
        ' Logging is internal and not exposed
    End Sub
End Class

Public Class MathLibrary
    Public Function Add(a As Integer, b As Integer) As Integer
        Return a + b
    End Function

    Public Function Subtract(a As Integer, b As Integer) As Integer
        Return a - b
    End Function

    Private Sub LogCalculation(operation As String, result As Integer)
        ' Logging is internal and not exposed
    End Sub
End Class

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

Conclusion

Tim Corey propose un guide clair et professionnel pour maîtriser les modificateurs d'accès C#, en montrant comment les utiliser efficacement pour créer des applications sécurisées, maintenables et professionnelles. Ses explications détaillées et ses exemples concrets rendent ce sujet accessible aux développeurs de tous niveaux.

Pour des aperçus plus approfondis et pour voir ces concepts en action, ne manquez pas de regarder l'intégralité de la vidéo de Tim et d'explorer son canal pour du contenu précieux sur le C# et d'autres sujets liés à la programmation. Il s'agit d'une ressource incontournable pour toute personne désireuse d'améliorer ses compétences en matière de développement !

Earn More by Sharing What You Love

Do you create content for developers working with .NET, C#, Java, Python, or Node.js? Turn your expertise into extra income!

Join our Affiliate program

Let's Stay in Touch!

Join our newsletter, you’ll get exclusive access on article updates. We value your privacy