W języku C #, jaka jest różnica między publicznym, prywatnym, chronionym i nie posiadającym modyfikatora dostępu?

Wszystkie lata mojej uczelni używam public, a chcieliby, aby znać różnicę między public, privatei protected?

Co też robi static, gdy nie ma nic?

Modyfikatory dostępu

Od docs.microsoft.com :

public

Dostęp do typu lub elementu można uzyskać za pomocą dowolnego kodu w tym samym zestawie lub innym zestawie, który się do niego odwołuje.

private

Dostęp do typu lub elementu można uzyskać tylko za pomocą kodu w tej samej klasie lub strukturze.

protected

Dostęp do typu lub elementu można uzyskać tylko za pomocą kodu w tej samej klasie lub strukturze lub w klasie pochodnej.

private protected (dodano w C # 7.2)

Dostęp do typu lub elementu można uzyskać tylko za pomocą kodu w tej samej klasie lub strukturze lub w klasie pochodnej z tego samego zestawu, ale nie z innego zestawu.

internal

Dostęp do typu lub elementu można uzyskać za pomocą dowolnego kodu w tym samym zestawie, ale nie z innego zestawu.

protected internal

Dostęp do typu lub elementu można uzyskać za pomocą dowolnego kodu w tym samym zestawie lub dowolnej klasy pochodnej w innym zestawie.

Gdy nie jest ustawiony żaden modyfikator dostępu, używany jest domyślny modyfikator dostępu. Tak więc zawsze istnieje jakaś forma modyfikatora dostępu, nawet jeśli nie jest ustawiona.

static modyfikator

Modyfikator statyczny w klasie oznacza, że ​​nie można utworzyć instancji klasy i że wszystkie jej elementy są statyczne. Element statyczny ma jedną wersję, niezależnie od liczby utworzonych wystąpień typu otaczającego.

Klasa statyczna jest w zasadzie taka sama jak klasa niestatyczna, ale jest jedna różnica: klasy statycznej nie można utworzyć instancji zewnętrznej. Innymi słowy, nie można użyć nowego słowa kluczowego do utworzenia zmiennej typu klasy. Ponieważ nie ma zmiennej instancji, dostęp do członków klasy statycznej można uzyskać, używając samej nazwy klasy.

Istnieje jednak coś takiego jak konstruktor statyczny . Każda klasa może mieć jedną z nich, w tym klasy statyczne. Nie można ich wywoływać bezpośrednio i nie mogą mieć parametrów (innych niż parametry dowolnego typu w samej klasie). Konstruktor statyczny jest wywoływany automatycznie w celu zainicjowania klasy przed utworzeniem pierwszej instancji lub odwołaniem się do dowolnego elementu statycznego. Wygląda tak:

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

    public static string Bar { get; set; }
}

Klasy statyczne są często używane jako usługi, możesz z nich korzystać w następujący sposób:

MyStaticClass.ServiceMethod(...);

Przegląd graficzny (podsumowanie w pigułce)

Ponieważ klasy statyczne są zapieczętowane, nie można ich dziedziczyć (z wyjątkiem Object), więc słowo kluczowe protected jest niepoprawne w klasach statycznych.

Aby zobaczyć ustawienia domyślne, jeśli nie umieścisz przed sobą modyfikatora dostępu, zobacz tutaj:
Domyślna widoczność dla klas C # i elementów (pól, metod itp.)?

Nie zagnieżdżone

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

Zagnieżdżone:

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

Są też słowa kluczowe zapieczętowane, przez co klasa nie jest dziedziczna.
Ponadto w VB.NET słowa kluczowe są czasami różne, więc tutaj ściągawka:

Publiczny - jeśli widzisz klasę, możesz zobaczyć metodę

Prywatne - Jeśli jesteś częścią tej klasy, a następnie można zobaczyć sposób, w przeciwnym razie nie.

Chroniony - taki sam jak prywatny, a także wszyscy potomkowie mogą również zobaczyć metodę.

Statyczny (klasa) - pamiętasz rozróżnienie między „klasą” a „przedmiotem”? Zapomnij o tym wszystkim. Są takie same z „statycznym”… klasa jest jedyną instancją samego siebie.

Statyczna (metoda) - Za każdym razem, gdy użyjesz tej metody, będzie ona mieć ramkę odniesienia niezależną od faktycznego wystąpienia klasy, której jest częścią.

Przesłanie niesamowitych diagramów z tej odpowiedzi .

Oto wszystkie modyfikatory dostępu na diagramach Venna, od bardziej ograniczających do bardziej wyuzdanych:

private:

private protected: - dodano w C # 7.2

internal:

protected:

protected internal:

public:

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

Odnośnie pytania o nic

• Typy przestrzeni nazw są domyślnie wewnętrzne
• Każdy typ elementu, w tym typy zagnieżdżone, są domyślnie prywatne

Jeszcze inne podejście wizualne obecnego modyfikatora dostępu (C # 7.2). Mam nadzieję, że schemat pomaga łatwiej zapamiętać
_{(kliknij obraz, aby wyświetlić interaktywny widok).}

Na zewnątrz wewnątrz

Jeśli masz problem z zapamiętaniem dwuznacznych modyfikatorów dostępu, pamiętaj o tym, że jesteś na zewnątrz .

• prywatny chroniony : prywatny na zewnątrz (ten sam zespół) chroniony wewnątrz (ten sam zespół)
• chroniony wewnętrzny : chroniony na zewnątrz (ten sam zespół) wewnętrzny wewnątrz (ten sam zespół)

Hmm

Zobacz tutaj: Modyfikatory dostępu .

W skrócie:

Publiczny daje metodzie lub typowi pełną widoczność z innych typów / klas.

Prywatny pozwala tylko typowi zawierającemu prywatną metodę / zmienną dostęp do prywatnej metody / zmiennej (zwróć uwagę, że zagnieżdżone klasy mają również dostęp do zawierających klasy prywatnych metod / zmiennych).

Protected jest podobny do prywatnego, z tym że klasy pochodne mogą również uzyskać dostęp do metod chronionych.

„Nic” jest odpowiednikiem VB.NET dla null. Chociaż jeśli mówisz o „niczym”, co oznacza „brak modyfikatora dostępu”, to zależy, chociaż bardzo surową zasadą (z pewnością w języku C #) jest to, że jeśli nie określisz wyraźnie modyfikatora dostępu, metoda / zmienna deklaracja jest zwykle tak ograniczona, jak to tylko możliwe. to znaczy

public class MyClass
{
    string s = "";
}

jest faktycznie taki sam jak:

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

Połączony artykuł MSDN będzie oferował pełny opis, gdy nie ma wyraźnie określonego modyfikatora dostępu.

publiczny - może być dostępny dla każdego w dowolnym miejscu.
prywatny - dostępny tylko z poziomu w klasie, której jest częścią.
chroniony - można uzyskać do niego dostęp wyłącznie z klasy lub dowolnego obiektu dziedziczącego poza klasę.

Nic nie jest jak zero, ale w VB.
Statyczny oznacza, że ​​masz jedną instancję tego obiektu, metodę dla każdej instancji tej klasy.

mmm ...

Statyczny oznacza, że ​​możesz uzyskać dostęp do tej funkcji bez posiadania instancji klasy.

Możesz uzyskać dostęp bezpośrednio z definicji klasy.

Status Prywatny wskazuje, że zmienne mogą być dostępne tylko przez obiekty tej samej klasy. Status chroniony rozszerza ten dostęp również na potomków klasy.

„Z powyższej tabeli widać szacunek między prywatnym a chronionym… myślę, że oba są takie same… więc jaka jest potrzeba tych dwóch osobnych poleceń”

Sprawdź łącze MSDN, aby uzyskać więcej informacji

Te modyfikatory dostępu określają, gdzie członkowie są widoczni. Prawdopodobnie powinieneś to przeczytać. Weź jako punkt wyjścia link podany przez IainMH.

Członkowie statyczni to jeden na klasę, a nie jeden na instancję.

Uważnie obserwuj dostępność swoich zajęć. Publiczne i chronione klasy i metody są domyślnie dostępne dla wszystkich.

Również Microsoft nie bardzo wyraźnie pokazuje modyfikatory dostępu (słowa kluczowe, publiczne, chronione itp.) Podczas tworzenia nowych klas w Visual Studio. Uważaj więc i pomyśl o dostępności swojej klasy, ponieważ jest to drzwi do wewnętrznych elementów implementacyjnych.

Myślę, że jest to związane z dobrym projektem OOP. Jeśli jesteś programistą biblioteki, chcesz ukryć wewnętrzne funkcjonowanie swojej biblioteki. W ten sposób możesz później zmodyfikować wewnętrzne funkcjonowanie biblioteki. Dlatego umieścisz członków i metody pomocnicze jako prywatne, a tylko metody interfejsu są publiczne. Metody, które należy zastąpić, powinny być chronione.

C # ma w sumie 6 modyfikatorów dostępu:

private : Element zadeklarowany z tą dostępnością może być widoczny w ramach typu zawierającego, nie jest widoczny dla żadnych typów pochodnych, innych typów w tym samym zestawie ani typów poza tym zestawem. tzn. dostęp jest ograniczony tylko do typu zawierającego.

chronione : Element zadeklarowany z tą dostępnością może być widoczny w typach pochodzących z typu zawierającego w zestawie zawierającym, a typy pochodzące z typu zawierającego poza zestawem zawierającym. tzn. dostęp jest ograniczony do pochodnych typów typu zawierającego.

wewnętrzny : Element zadeklarowany z tą dostępnością może być widoczny w zespole zawierającym ten element, nie jest widoczny dla żadnego zestawu poza zespołem zawierającym. tzn. dostęp jest ograniczony do ograniczania się tylko do złożenia.

wewnętrzny chroniony : Element zadeklarowany z tą dostępnością może być widoczny w typach pochodzących z typu zawierającego wewnątrz lub na zewnątrz zestawu zawierającego, jest również widoczny dla wszystkich typów w zestawie zawierającym. tzn. dostęp jest ograniczony do zawierania typów zestawu lub pochodnych.

public : Element zadeklarowany z tą dostępnością może być widoczny w zestawie zawierającym ten element lub w dowolnym innym zestawie, który odwołuje się do zestawu zawierającego. tzn. dostęp nie jest ograniczony.

C # 7.2 dodaje nowy poziom dostępności:

prywatny chroniony : Element zadeklarowany z tą dostępnością może być widoczny w typach pochodzących z tego typu zawierającego w zestawie zawierającym. Nie jest widoczny dla żadnego typu niepochodzącego z typu zawierającego lub na zewnątrz zestawu zawierającego. tzn. dostęp jest ograniczony do typów pochodnych w zestawie zawierającym.

Źródło zawierające przykładowy kod nowego prywatnego modyfikatora dostępu chronionego

Wszystkie opisy modyfikatorów dostępu do C #