In C#, was ist der Unterschied zwischen public, private, protected, und keinen access-modifier?

Zugriffsmodifizierer

Vom docs.microsoft.com

öffentlichen

Den Typ oder member kann zugegriffen werden, von jedem code in der gleichen assembly oder einer anderen assembly verweist.

private

Den Typ oder member kann nur zugegriffen werden, indem code in der gleichen Klasse oder struct.

geschützt

Den Typ oder member kann nur zugegriffen werden, indem code in der gleichen Klasse oder Struktur oder in einer abgeleiteten Klasse.

private protected (Hinzugefügt in C# 7.2)

Den Typ oder member kann nur zugegriffen werden, indem code in der gleichen Klasse oder Struktur oder in einer abgeleiteten Klasse von der gleichen assembly, aber nicht aus einer anderen assembly.

internen

Den Typ oder member kann zugegriffen werden, von jedem code in der gleichen assembly, aber nicht aus einer anderen assembly.

geschützten internen

Den Typ oder member kann zugegriffen werden, von jedem code in der gleichen assembly oder von jeder abgeleiteten Klasse in einer anderen assembly.

Wenn keine zugriffsmodifizierer gesetzt ist, wird eine standardmäßige access-modifier verwendet wird. Es gibt also immer eine form von access-modifier-auch wenn es nicht gesetzt wird.

Statische

Den static-Modifizierer für eine Klasse bedeutet, dass die Klasse nicht instanziiert werden kann, und dass alle seine Mitglieder sind statisch. Eine statische member verfügt über eine version, unabhängig davon, wie viele Instanzen von Ihrer UMMANTELUNG Typ erstellt werden.

Einer statischen Klasse ist im Grunde das gleiche wie eine nicht-statische Klasse, aber es gibt einen Unterschied: eine statische Klasse kann nicht extern instanziert. In anderen Worten, Sie können nicht das Schlüsselwort new, verwenden um erstellen Sie eine variable des class-Typs. Weil es keine Instanz-Variablen der Zugriff auf die member einer statischen Klasse mit dem Klassennamen selbst.

Jedoch, es gibt eine solche Sache wie ein statische Konstruktor. Jede Klasse kann eine von diesen, einschließlich statische Klassen. Sie kann nicht direkt aufgerufen werden & keine Parameter (außer einer Typ-Parameter die Klasse selbst). Ein statischer Konstruktor wird automatisch aufgerufen, initialisiert die Klasse vor der ersten Instanz erstellt wird, oder beliebige statische Elemente referenziert werden. Sieht wie folgt aus:

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

    public static string Bar { get; set; }
}

Statische Klassen werden Häufig als Service verwendet werden, können Sie Sie wie folgt:

MyStaticClass.ServiceMethod(...);

Einer grafischen übersicht (summary in a nutshell)

Für die Standardwerte wenn Sie keinen access modifier vor, siehe hier:

Standard-Sichtbarkeit für C# - Klassen und-member (Felder, Methoden, etc)?

Nicht verschachtelte

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

Verschachtelt:

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

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.

Siehe hier: Zugriffsmodifizierer.

Kurz gesagt:

Öffentlichkeit gibt die Methode oder geben Sie die vollständige Sichtbarkeit von anderen Typen/Klassen.

Private erlaubt nur der Typ mit der privaten Methode/variable Zugriff auf die private Methode/variable (beachten Sie, dass verschachtelte Klassen haben auch Zugriff auf die Klassen mit private Methoden/Variablen).

Geschützt ähnlich ist zu private, abgesehen von abgeleiteten Klassen können auch den Zugriff auf geschützte Methoden.

"Nichts" ist VB.NET's äquivalent zu null. Obwohl, wenn man sich auf "nichts" im Sinne von "keinen access-modifier", dann hängt es ab, obwohl eine sehr grobe Faustregel (natürlich in C#) ist, dass wenn Sie nicht explizit angeben, eine access-modifier der Methode/Variablendeklaration ist in der Regel als eingeschränkt, wie es sein kann.
also

public class MyClass
{
    string s = "";
}

ist effektiv das gleiche wie:

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

Den verlinkten MSDN-Artikel bieten wir eine vollständige Beschreibung, wenn es keine zugriffsmodifizierer explizit angegeben.

Doch einen anderen visuellen Ansatz der aktuellen access modifier (C# 7.2). Hoffentlich wird das schema hilft, sich zu erinnern, ist es einfacher

_{(klicken Sie auf das Bild für eine interaktive Ansicht).}

Aussen Innen

Wenn Sie kämpfen, um zu erinnern, die zwei-formuliert zugriffsmodifizierer, erinnern außen-innen -.

• private protected: private außerhalb (die Versammlung) geschützt innen (Versammlung)
• geschützten internen: geschützt außerhalb (die Versammlung) internen innen (Versammlung)

Den status des Privaten zeigt, dass die Variablen kann nur zugegriffen werden, Objekte der gleichen Klasse. Geschützt status erweitert, der Zugang zu den Nachkommen gehören der Klasse als gut.

"aus der obigen Tabelle können wir sehen, den Unterschied zwischen private und protected... bin denke, dass beides das gleiche ....also, was die Notwendigkeit, dass zwei getrennte Befehl"

Überprüfen MSDN link für mehr Informationen

Vorsichtig, beobachten Sie Ihre Zugänglichkeit Ihrer Klassen. Öffentlichen und geschützten Klassen und Methoden sind standardmäßig für jeden zugänglich.

Auch Microsoft ist nicht sehr explizite zeigen zugriffsmodifizierer (public, protected, etc.. keywords), wenn neue Klassen in Visual Studio erstellt werden. Also, nehmen gute Pflege, und denken Sie über Ihre Zugänglichkeit Ihrer Klasse, weil es die Tür zu Ihrer Umsetzung Interna.

C# hat insgesamt 6 zugriffsmodifizierer:

private: Das Mitglied erklärt mit diese Zugänglichkeit kann sichtbar sein, innerhalb der mit Typ, es ist nicht sichtbar, auch abgeleitete Typen, andere Typen in der gleichen assembly oder Arten, die außerhalb der mit der Montage. d.h., der Zugriff ist beschränkt auf die mit nur Typ.

geschützt: Das Mitglied erklärt mit diese Zugänglichkeit kann sichtbar sein, innerhalb der Arten abgeleitet vom übergeordneten Typ innerhalb der mit der Montage, und die Typen, die, abgeleitet aus den mit Typ-außerhalb des mit der Montage. d.h., der Zugriff ist beschränkt auf abgeleitete Typen, die mit type.

internen: Das Mitglied erklärt mit diese Zugänglichkeit kann sichtbar innerhalb der assembly, in der sich das Mitglied, es ist nicht sichtbar bei Montage außerhalb des mit der Montage. d.h., der Zugriff ist beschränkt auf die mit der Montage nur.

internen, geschützten: Das Mitglied erklärt mit diese Zugänglichkeit kann sichtbar sein, innerhalb der Arten abgeleitet vom übergeordneten Typ innerhalb oder außerhalb der mit der Montage, ist es auch sichtbar für alle Arten innerhalb der mit der Montage. d.h., der Zugriff ist beschränkt auf die mit der Montage oder abgeleitete Typen.

öffentlichen: Das Mitglied erklärt mit diese Zugänglichkeit kann sichtbar innerhalb der assembly, in der sich das Mitglied, oder jede andere Versammlung, verweist auf die mit der Montage. d.h., der Zugriff ist nicht beschränkt.

C# 7.2 ist das hinzufügen einer neuen Ebene der Zugänglichkeit:

private protected: Das Mitglied erklärt mit diese Zugänglichkeit kann sichtbar sein, innerhalb der Arten abgeleitet aus diesen übergeordneten Typ innerhalb der mit der Montage. Es ist nicht sichtbar für alle Arten stammt nicht aus dem enthaltenden Typ oder außerhalb des enthaltenden Baugruppe. d.h., der Zugriff ist beschränkt auf abgeleitete Typen innerhalb der mit der Montage.

Quelle inklusive einem Beispiel-code of the new private protected access modifier