c# private - Quelle est la différence entre public, privé, protégé et rien?




protected c++ (13)

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?


Answers

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


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

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.


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.


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 :


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 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 généralement aussi limitée que possible. 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é.


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

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.


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

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.


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

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.


Tout d'abord, cela concerne la convivialité. Si vous utilisez l'héritage, la classe Team exposera un comportement (méthodes) conçu uniquement pour la manipulation d'objets. Par exemple, les AsReadOnly() ou CopyTo(obj) n'ont aucun sens pour l'objet d'équipe. Au lieu de la AddRange(items) , vous voudrez probablement une méthode AddPlayers(players) plus descriptive.

Si vous voulez utiliser LINQ, implémenter une interface générique telle que ICollection<T> ou IEnumerable<T> aurait plus de sens.

Comme mentionné, la composition est la bonne façon de s'y prendre. Implémentez simplement une liste de joueurs en tant que variable privée.





c# .net asp.net access-modifiers