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

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

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

protégé - même que privé, plus tous descendants peut également voir la méthode.

Statique (classe) - Rappelez-vous la distinction entre "Classe" et "Objet" ? Oubliez tout ça. Ils sont de même avec "statique"... la classe est la seule instance en elle-même.

Static (method) - chaque fois que vous utilisez cette méthode, elle aura un cadre de référence indépendant de l'instance réelle de la classe dont elle fait partie.

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

pour les valeurs par défaut si vous ne mettez pas de modificateur d'accès devant, voir ici:

visibilité par défaut pour les classes C# et les membres (champs, méthodes, etc.)?

Non emboîtés

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

emboîté:

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 sont privés 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 le type d'une visibilité complète à partir d'autres types/classes.

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

protégé est similaire à privé, sauf que les classes dérivées peuvent également accéder aux méthodes protégées.

"Rien" est VB.NET's équivalent à la valeur null. Bien que si vous faites référence à" rien "qui signifie" aucun modificateur d'accès", Cela dépend, bien qu'une règle empirique (certainement en C#) soit que si vous ne spécifiez pas explicitement un modificateur d'accès, la méthode/déclaration de variable est habituellement comme restreint comme il peut être. c'est à dire

public class MyClass
{
    string s = "";
}

est effectivement la même chose que:

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

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

public - peut être accessible par n'importe qui n'importe où.

privé - ne peut être accédé à partir de avec dans la classe dans laquelle il fait partie.

protégé - ne peut être consulté qu'avec dans la classe ou tout objet qui hérite de la classe.

Rien n'est comme nulle mais en VB.

Statique signifie que vous avez une instance de cet objet, méthode pour chaque instance de cette classe.

Reposter le génial diagrammes à partir de cette réponse .

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

private :

private protected : - ajouté en C# 7.2

internal :

protected :

protected internal :

public :

mmm...

Statique signifie que vous pouvez accéder à cette fonction sans avoir une instance de la classe.

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

un statut de Private indique que les variables ne peuvent être consultées que par des objets de la même classe. Le statut protégé étend cet accès aux descendants de la catégorie.

" du tableau ci-dessus nous pouvons voir la déférence entre privé et protégé... je pense que les deux sont les mêmes....donc, ce que la nécessité de ces deux commande séparée"

Vérifier MSDN lien pour plus d'informations

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

les membres statiques sont un par classe et pas un par instance.

attention à l'accessibilité de vos cours. Les classes et méthodes publiques et protégées sont par défaut accessibles à tous.

aussi Microsoft n'est pas très explicite en montrant les modificateurs d'accès (public, protégé, etc.. mots clés) lors de la création de nouvelles classes dans Visual Studio. Donc, faites attention et pensez à votre accessibilité de votre classe parce que c'est la porte à vos internes de mise en œuvre.

je pense qu'il est lié à la bonne conception OOP. 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 votre bibliothèque rouages plus tard. Donc vous mettez vos méthodes de membres et d'assistants comme privées, et seules les méthodes d'interface sont publiques. Les méthodes qui devraient être écrasées devraient être protégées.

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

privé : le membre déclaré Avec cette accessibilité peut être visible à l'intérieur du type contenant, il n'est pas visible à tous les types dérivés, autres types dans le même ensemble ou types à l'extérieur de l'ensemble contenant. c'est à dire, l'accès est limité du type contenant uniquement.

protégé : le membre a déclaré Avec cette l'accessibilité peut être visible dans le type dérivé du type contenant dans le contenant de l'assemblée, et les types dérivés du type contenant à l'extérieur du contenant de l'assemblée. c'est à dire, l'accès est limité aux types dérivés du type contenant.

interne : le membre déclaré Avec cette accessibilité peut être visible à l'intérieur de l'Assemblée contenant ce membre, il n'est visible à aucune assemblée en dehors de l'Assemblée contenant. c'est à dire, l'accès est limité contenant de l'assemblée.

protection interne : le membre déclaré Avec cette accessibilité peut être visible dans les types dérivés du type contenant à l'intérieur ou à l'extérieur de l'assemblage contenant, il est également visible à tous les types à l'intérieur de l'assemblage contenant. c'est-à-dire que l'accès est limité à l'assemblage ou aux types dérivés.

public : le membre a déclaré avec cette accessibilité peut être visible au sein de l'assemblée qui comprend ce membre, ou de toute autre assemblée qui fait référence à l'assemblée qui contient. c'est à dire, l'accès n'est pas limité.

C# 7.2 ajoute un nouveau niveau d'accessibilité:

private protected : le membre déclaré Avec cette accessibilité peut être visible à l'intérieur des types dérivés de ce type contenant à l'intérieur de l'ensemble contenant. Il n'est pas visible à tous les types provenant du type contenant, ou à l'extérieur de l'assemblage contenant. c'est à dire, l'accès est limité aux types dérivés dans le contenant de l'assemblée.

Source incluant un code type du nouveau modificateur d'accès privé protégé