c# - openclassroom - public private protected




Quelle est la différence entre public, privé, protégé et rien? (10)

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.

Lorsque aucun modificateur d'accès n'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 existe une telle chose comme un 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(...);

Toutes mes années d'université j'ai utilisé public , et aimerais connaître la différence entre public , private , et protected ?

Qu'est-ce que le static fait par opposition à ne rien avoir?


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

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.


En ce qui concerne la question de Nothing

  • 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

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


Repositionner les diagrammes impressionnants de cette réponse .

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

private :

private protected : - ajouté en C # 7.2

internal :

protected :

protected internal :

public :


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

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érifiez le lien MSDN pour plus d'informations


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

Privé - Si vous faites partie de la classe, alors vous pouvez voir la méthode, sinon non.

Protégé - Même que Privé, plus tous les descendants peuvent également voir la méthode.

Statique (classe) - Rappelez-vous la distinction entre "Classe" et "Objet"? Oublie tout ça. Ils sont identiques avec "statique" ... la classe est l'instance unique de lui-même.

Statique (méthode) - 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.


public - peut être accessible par n'importe qui n'importe où.
privé - ne peut être accessible qu'à partir de dans la classe dont il fait partie.
protected - ne peut être 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, méthode pour chaque instance de cette classe.







access-modifiers