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


Toutes mes années de collège, j'ai utilisé public, et j'aimerais connaître la différence entre public, private, et protected?

Aussi qu'est-ce que static faire par opposition à ne rien avoir?


620
2018-03-05 13:48


origine


Réponses:


Modificateurs d'accès

Publique

Le type ou le membre peut être accédé par tout autre code dans le même assembly ou un autre assembly qui le référence.

privé

Le type ou le membre ne peut être accédé que par du code dans la même classe ou structure.

protégé

Le type ou le membre ne peut être accédé que par du code dans la même classe ou structure, ou dans une classe dérivée.

interne

Le type ou le membre peut être accédé par n'importe quel code dans le même assembly, mais pas par un autre assembly.

protégé interne

Le type ou le membre peut être accédé par n'importe quel code dans le même assembly ou par n'importe quelle classe dérivée dans un autre assembly.

Quand pas de modificateur d'accès est défini, un modificateur d'accès par défaut est utilisé. Il y a donc toujours une forme de modificateur d'accès même s'il n'est pas défini.

Statique

Le modificateur static sur une classe signifie que la classe ne peut pas être instanciée et que tous ses membres sont statiques. Un membre statique possède une version, quel que soit le nombre d'occurrences de son type englobant.

Une classe statique est fondamentalement identique à une classe non statique, mais il existe une différence: une classe statique ne peut pas être instanciée de manière externe. En d'autres termes, vous ne pouvez pas utiliser le nouveau mot-clé pour créer une variable du type de classe. Parce qu'il n'y a aucune variable d'instance, vous accédez aux membres d'une classe statique en utilisant le nom de classe lui-même.

Cependant, il y a une telle chose comme constructeur statique. Toute classe peut en avoir une, y compris des classes statiques. Ils ne peuvent pas être appelés directement et ne peuvent pas avoir de paramètres (autres que les paramètres de type sur la classe elle-même). Un constructeur statique est appelé automatiquement pour initialiser la classe avant que la première instance soit créée ou que des membres statiques soient référencés. Ressemble à ça:

static class Foo()
{
    static Foo()
    {
        Bar = "fubar";
    }

    public static string Bar { get; set; }
}

Les classes statiques sont souvent utilisées en tant que services, vous pouvez les utiliser comme suit:

MyStaticClass.ServiceMethod(...);

882
2018-03-05 13:55



Publique - 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, sinon, non.

Protégé - Même que Privé, plus tout descendance peut également voir la méthode.

Statique (classe) - Rappelez-vous la distinction entre "Class" et "Object"? Oublie tout ça. Ils sont les mêmes avec "statique" ... la classe est l'instance unique 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 dont il fait partie.


143
2018-03-05 14:26



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

Visibility

Pour les valeurs par défaut si vous ne mettez pas de modificateur d'accès en avant, voir ici:
Visibilité par défaut pour les classes et membres C # (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

129
2018-04-11 08:00



En ce qui concerne 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

22
2018-03-05 17:27



enter image description here

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

16
2018-05-24 07:19



Hmm.

Vois 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 n'autorise que le type contenant la méthode / l'accès à la variable privée à la méthode / variable privée (notez que les classes imbriquées ont également accès aux classes / méthodes privées contenant les classes).

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

"Nothing" est l'équivalent de null de VB.NET. Bien que si vous faites référence à "rien" signifiant "aucun modificateur d'accès", alors cela dépend, bien qu'une règle empirique très grossière (certainement en C #) soit que si vous ne spécifiez pas explicitement un modificateur d'accès, la méthode / variable déclaration est habituellement comme limité comme ça peut ê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 aucun modificateur d'accès explicitement spécifié.


11
2018-03-05 13:53



Publique - Peut être accessible par n'importe qui n'importe où.
privé - On ne peut y accéder qu'à partir de la classe dont il fait partie.
protégé - ne peut être accessible qu'à partir de with dans la classe ou 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, méthode pour chaque instance de cette classe.


8
2018-03-05 13:55



mmm ...

Statique 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.


4
2018-03-05 13:53



Un statut de Privé indique que les variables ne peuvent être accédées 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.

"à partir 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 .... alors quel est le besoin de cette commande séparée"

Vérifier MSDN lien pour plus d'informations


4
2017-07-07 08:13



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.


3
2018-03-05 13:52



Surveillez attentivement votre 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 des modificateurs d'accès (public, protégé, etc. mots-clés) quand de nouvelles classes dans Visual Studio sont créées. Alors, prenez bien soin de vous et pensez à votre accessibilité de votre classe car c'est la porte d'entrée de vos implémentations internes.


3
2018-03-05 14:21