modifiers - c# visibility




Was ist der Unterschied zwischen öffentlich, privat, geschützt und nichts? (10)

All meine Studienjahre habe ich public und würde gerne den Unterschied zwischen public , private und protected wissen?

Auch, was macht static nichts?


Zugriffsmodifizierer

Öffentlichkeit

Auf den Typ oder das Element kann von jedem anderen Code in derselben Assembly oder einer anderen Assembly zugegriffen werden, die darauf verweist.

Privatgelände

Auf den Typ oder das Member kann nur durch Code in derselben Klasse oder Struktur zugegriffen werden.

geschützt

Auf den Typ oder das Member kann nur durch Code in derselben Klasse oder Struktur oder in einer abgeleiteten Klasse zugegriffen werden.

intern

Auf den Typ oder das Element kann von jedem Code in derselben Assembly, aber nicht von einer anderen Assembly zugegriffen werden.

geschützt intern

Auf den Typ oder das Member kann von jedem Code in derselben Assembly oder von jeder abgeleiteten Klasse in einer anderen Assembly zugegriffen werden.

Wenn kein Zugriffsmodifizierer festgelegt ist, wird ein Standardzugriffsmodifikator verwendet. Es gibt also immer eine Form von Zugriffsmodifizierer, auch wenn sie nicht gesetzt ist.

Statisch

Der statische Modifikator einer Klasse bedeutet, dass die Klasse nicht instanziiert werden kann und dass alle ihre Member statisch sind. Ein statisches Member hat unabhängig davon, wie viele Instanzen seines umschließenden Typs erstellt wurden, eine Version.

Eine statische Klasse ist im Grunde die gleiche wie eine nicht statische Klasse, aber es gibt einen Unterschied: Eine statische Klasse kann nicht extern instanziiert werden. Mit anderen Worten, Sie können das neue Schlüsselwort nicht verwenden, um eine Variable des Klassentyps zu erstellen. Da keine Instanzvariable vorhanden ist, greifen Sie auf die Mitglieder einer statischen Klasse zu, indem Sie den Klassennamen selbst verwenden.

Es gibt jedoch so etwas wie einen statischen Konstruktor . Jede Klasse kann eine davon haben, einschließlich statischer Klassen. Sie können nicht direkt aufgerufen werden und können keine Parameter haben (außer irgendwelchen Typparametern in der Klasse selbst). Ein statischer Konstruktor wird automatisch aufgerufen, um die Klasse zu initialisieren, bevor die erste Instanz erstellt oder auf statische Member verwiesen wird. Sieht aus wie das:

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

    public static string Bar { get; set; }
}

Statische Klassen werden oft als Dienste verwendet, Sie können sie wie folgt verwenden:

MyStaticClass.ServiceMethod(...);

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

C # hat insgesamt 6 Zugriffsmodifizierer:

privat : Das mit dieser Zugriffsmöglichkeit deklarierte Element kann innerhalb des umschließenden Typs sichtbar sein, es ist für abgeleitete Typen, andere Typen in derselben Assembly oder Typen außerhalb der umgebenden Assembly nicht sichtbar. dh der Zugriff ist nur auf den enthaltenden Typ beschränkt.

protected : Das mit dieser Zugriffsmöglichkeit deklarierte Element kann innerhalb der Typen angezeigt werden, die vom enthaltenden Typ innerhalb der enthaltenden Assembly abgeleitet sind, und die Typen, die vom enthaltenden Typ außerhalb der enthaltenden Assembly abgeleitet sind. dh der Zugriff ist auf abgeleitete Typen des enthaltenden Typs beschränkt.

internal : Das mit dieser Barrierefreiheit deklarierte Mitglied kann in der Assembly, die dieses Mitglied enthält, sichtbar sein. Es ist für keine Assembly außerhalb der übergeordneten Assembly sichtbar. dh der Zugriff beschränkt sich nur auf die Assembly.

internal protected : Das mit dieser Accessibility deklarierte Member kann innerhalb der Typen sichtbar sein, die vom enthaltenden Typ innerhalb oder außerhalb der enthaltenden Assembly abgeleitet sind. Es ist auch für alle Typen innerhalb der enthaltenden Assembly sichtbar. dh der Zugriff ist beschränkt auf Assembly oder abgeleitete Typen.

public : Das mit dieser Barrierefreiheit deklarierte Member kann in der Assembly angezeigt werden, die dieses Member oder eine andere Assembly enthält, die auf die enthaltene Assembly verweist. dh der Zugriff ist nicht begrenzt.

C # 7.2 fügt eine neue Zugänglichkeit hinzu:

private protected : Das mit dieser Erreichbarkeit deklarierte Mitglied kann in den Typen sichtbar sein, die von diesem enthaltenden Typ innerhalb der enthaltenden Assembly abgeleitet sind. Es ist für keine Typen sichtbar, die nicht vom umgebenden Typ oder außerhalb der umgebenden Baugruppe abgeleitet sind. dh der Zugriff ist auf abgeleitete Typen innerhalb der enthaltenden Assembly beschränkt.

Quelle enthält einen Beispielcode des neuen privaten Zugriffsmodifizierers


Die fantastischen Diagramme aus dieser Antwort umstellen.

Hier sind alle Zugriffsmodifizierer in Venn-Diagrammen, von begrenzender zu promisquider:

private :

private protected : - hinzugefügt in C # 7.2

internal :

protected :

protected internal :

public :


Ein Status von Privat zeigt an, dass auf Variablen nur von Objekten derselben Klasse zugegriffen werden kann. Geschützter Status erweitert diesen Zugriff auch auf Nachkommen der Klasse.

"Von der obigen Tabelle können wir die Ehrerbietung zwischen privat und geschützt sehen ... bin denke, dass beide gleich sind .... also, was die Notwendigkeit für diesen zwei getrennten Befehl"

Überprüfen Sie den MSDN Link für weitere Informationen


Eine grafische Übersicht (Zusammenfassung in Kürze)

Für die Standardwerte, wenn Sie keinen Zugriffsmodifizierer in den Vordergrund stellen, siehe hier:
Standardsichtbarkeit für C # -Klassen und -Member (Felder, Methoden usw.)?

Nicht verschachtelt

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

Geschachtelt:

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

Ich denke, es hängt mit gutem OOP-Design zusammen. Wenn Sie Entwickler einer Bibliothek sind, möchten Sie die inneren Funktionen Ihrer Bibliothek verbergen. Auf diese Weise können Sie später Ihre Bibliotheksinnenfunktionen ändern. Sie legen also Ihre Mitglieder und Hilfsmethoden als privat fest, und nur die Schnittstellenmethoden sind öffentlich. Methoden, die überschrieben werden sollen, sollten geschützt werden.


In Bezug auf die Frage nach dem Nichts

  • Namespace-Typen sind standardmäßig intern
  • Alle Typen, einschließlich verschachtelter Typen, sind standardmäßig privat

Öffentlich - Wenn Sie die Klasse sehen können, können Sie die Methode sehen

Privat - Wenn Sie Teil der Klasse sind, können Sie die Methode sehen, andernfalls nicht.

Geschützt - Wie Privat, und alle Nachkommen können auch die Methode sehen.

Statisch (Klasse) - Denken Sie an die Unterscheidung zwischen "Klasse" und "Objekt"? Vergiss das alles. Sie sind identisch mit "statisch" ... die Klasse ist die einzige Instanz ihrer selbst.

Static (Methode) - Immer wenn Sie diese Methode verwenden, hat sie einen Referenzrahmen unabhängig von der tatsächlichen Instanz der Klasse, zu der sie gehört.


öffentlich - kann von jedem überall zugänglich sein.
privat - kann nur von mit in der Klasse zugegriffen werden, zu der es gehört.
protected - kann nur von with in der Klasse oder von jedem Objekt, das von der Klasse erbt, zugegriffen werden.

Nichts ist wie Null, sondern in VB.
Statisch bedeutet, dass Sie für jede Instanz dieser Klasse eine Instanz dieses Objekts haben.





access-modifiers