Quelle est la différence entre public, privé, protégé et n'ayant pas de modificateur d'accès?

Public - Si vous pouvez voir la classe, alors vous pouvez voir la méthode

Private - Si vous êtes une partie de la classe, alors vous pouvez voir la méthode, pas autrement.

Protected - Identique à Private, plus tous les descendants peuvent également voir la méthode.

Statique (classe) - n'oubliez pas la distinction entre "Classe" et "Objet" ? Oubliez tout ça. Ils sont les mêmes avec "statique"... la classe est la seule et unique instance de lui-même.

Statique (méthode) - Chaque fois que vous utilisez cette méthode, il aura un cadre de référence indépendant de l'instance réelle de la classe à laquelle il est partie.

Un aperçu graphique (résumé en un mot)

Pour les valeurs par défaut si vous ne mettez aucun modificateur d'accès en face, voir ici:
Visibilité par défaut pour les classes C# et les membres (champs, méthodes, etc.)?

Non imbriqué

enum                              public
non-nested classes / structs      internal
interfaces                        internal
delegates in namespace            internal
class/struct member(s)            private
delegates nested in class/struct  private

Imbriqué:

nested enum      public
nested interface public
nested class     private
nested struct    private

Concernant la question de Rien

• Les types d'espaces de noms sont internes par défaut
• Tout membre de type, y compris les types imbriqués, est privé par défaut

using System;

namespace ClassLibrary1
{
    public class SameAssemblyBaseClass
    {
        public string publicVariable = "public";
        protected string protectedVariable = "protected";
        protected internal string protected_InternalVariable = "protected internal";
        internal string internalVariable = "internal";
        private string privateVariable = "private";
        public void test()
        {
            // OK
            Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(publicVariable);

            // OK
            Console.WriteLine(protectedVariable);

            // OK
            Console.WriteLine(internalVariable);

            // OK
            Console.WriteLine(protected_InternalVariable);
        }
    }

    public class SameAssemblyDerivedClass : SameAssemblyBaseClass
    {
        public void test()
        {
            SameAssemblyDerivedClass p = new SameAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(privateVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }

    public class SameAssemblyDifferentClass
    {
        public SameAssemblyDifferentClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.internalVariable);

            // NOT OK
            // Console.WriteLine(privateVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            //Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);
        }
    }
}

 using System;
        using ClassLibrary1;
        namespace ConsoleApplication4

{
    class DifferentAssemblyClass
    {
        public DifferentAssemblyClass()
        {
            SameAssemblyBaseClass p = new SameAssemblyBaseClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            // Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protectedVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protectedVariable);

            // Error : 'ClassLibrary1.SameAssemblyBaseClass.protected_InternalVariable' is inaccessible due to its protection level
            // Console.WriteLine(p.protected_InternalVariable);
        }
    }

    class DifferentAssemblyDerivedClass : SameAssemblyBaseClass
    {
        static void Main(string[] args)
        {
            DifferentAssemblyDerivedClass p = new DifferentAssemblyDerivedClass();

            // NOT OK
            // Console.WriteLine(p.privateVariable);

            // NOT OK
            //Console.WriteLine(p.internalVariable);

            // OK
            Console.WriteLine(p.publicVariable);

            // OK
            Console.WriteLine(p.protectedVariable);

            // OK
            Console.WriteLine(p.protected_InternalVariable);

            SameAssemblyDerivedClass dd = new SameAssemblyDerivedClass();
            dd.test();
        }
    }
}

Hmm.

Voir ici: Modificateurs d'Accès.

En un mot:

Public donne à la méthode ou au type une visibilité complète à partir d'autres types/classes.

Private autorise uniquement le type contenant la méthode/variable privée à accéder à la méthode/variable privée (notez que les classes imbriquées ont également accès aux méthodes/variables privées des classes contenant).

Protected est similaire à private sauf que les classes dérivées peuvent également accéder à protected méthode.

"Rien" est VB.NET équivalent à null. Bien que si vous faites référence à " rien "signifiant" pas de modificateur d'accès", cela dépend, bien qu'une règle empirique très approximative (certainement en C#) soit que si vous ne spécifiez pas explicitement un modificateur d'accès, la déclaration de méthode/variable est généralement restricted comme il peut l'être. c'est à dire

public class MyClass
{
    string s = "";
}

Est effectivement le même que:

public class MyClass
{
    private string s = "";
}

L'article MSDN lié offrira une description complète lorsqu'il n'y a pas d'accès modificateur explicitement spécifié.

Public - peut être accessible par n'importe qui n'importe où.
private - n'est accessible qu'à partir de with dans la classe dont il fait partie.
protected - n'est accessible qu'à partir de with dans la classe ou de tout objet qui hérite de la classe.

Rien n'est comme null mais dans VB.
Statique signifie que vous avez une instance de cet objet, la méthode pour chaque instance de cette classe.

Republier les diagrammes impressionnants de cette réponse.

Voici tous les modificateurs d'accès dans les diagrammes de Venn, de plus limitant à plus promiscuous:

private:

private protected: - ajouté dans C# 7.2

internal:

protected:

protected internal:

public:

Mmm...

Static signifie que vous pouvez accéder à cette fonction sans avoir d'instance de la classe.

Vous pouvez accéder directement à partir de la définition de classe.

Un statut Privé indique que les variables ne sont accessibles que par des objets de la même classe. Le statut protégé étend cet accès pour inclure également les descendants de la classe.

"dans le tableau ci-dessus, nous pouvons voir la déférence entre privé et protégé... je pense que les deux sont les mêmes.... alors, quelle est la nécessité de cette commande séparée "

Vérifiez lien MSDN pour plus d'informations

Ces modificateurs d'accès spécifient où vos membres sont visibles. Vous devriez probablement lire ceci. Prenez le lien donné par IainMH comme point de départ.

Les membres statiques sont un par classe et non un par instance.

Surveillez attentivement votre accessibilité de vos cours. Les classes et méthodes publiques et protégées sont par défaut accessibles à tous.

De plus, Microsoft n'est pas très explicite dans l'affichage des modificateurs d'accès (public, protégé, etc.. mots-clés) lorsque de nouvelles classes dans Visual Studio sont créées. Alors, prenez bien soin et pensez à votre accessibilité de votre classe car c'est la porte à vos internes d'implémentation.

Je pense que c'est lié à une bonne conception de POO. Si vous êtes un développeur d'une bibliothèque que vous souhaitez masquer le fonctionnement interne de votre bibliothèque. De cette façon, vous pouvez modifier le fonctionnement interne de votre bibliothèque plus tard. Vous mettez donc vos membres et vos méthodes d'assistance comme privés, et seules les méthodes d'interface sont publiques. Les méthodes qui doivent être écrasées doivent être protégées.

C# a au total 6 modificateurs d'accès:

Private: Le membre déclaré avec cette accessibilité peut être visible dans le type containing, il n'est visible par aucun type dérivé, d'autres types dans le même assembly ou des types en dehors de l'assembly containing. c'est-à-dire que l'accès est limité au type contenant uniquement.

Protected : Le membre déclaré avec cette accessibilité peut être visible dans les types dérivés du type contenant dans le ensemble contenant, et les types dérivés du type contenant en dehors de l'ensemble contenant. c'est à dire, l'accès est limité aux types dérivés du type contenant.

Internal: Le membre déclaré avec cette accessibilité peut être visible dans l'assemblage contenant ce membre, il n'est visible par aucun assemblage en dehors de l'assemblage contenant. c'est à dire, l'accès est limité contenant de l'assemblée.

Interne protégé : Le membre déclaré avec ce l'accessibilité peut être visible dans les types dérivés du type contenant à l'intérieur ou à l'extérieur de l'assemblage contenant, elle est également visible pour tous les types de l'assemblage contenant. c'est-à-dire que l'accès est limité à contenir des assemblys ou des types dérivés.

Public: Le membre déclaré avec cette accessibilité peut être visible dans l'assemblée contenant ce membre, ou toute autre assemblée faisant référence à l'assemblée contenant. c'est à dire, l'accès n'est pas limité.

C# 7.2 est l'ajout d'un nouveau niveau d'accessibilité:

Private protected: Le membre déclaré avec cette accessibilité peut être visible dans les types dérivés de ce type contenant dans l'assembly contenant. Il n'est visible par aucun type non dérivé du type contenant ou en dehors de l'assemblage contenant. c'est-à-dire que l'accès est limité aux types dérivés dans l'assemblage contenant.

Source incluant un exemple de code du nouvel accès privé protégé modificateur