W C#, jaka jest różnica między public, private, protected i having no access modifier?

Graficzny przegląd (podsumowanie w skrócie)

Ponieważ klasy statyczne są zapieczętowane, nie mogą być dziedziczone (z wyjątkiem obiektu), więc słowo kluczowe protected jest nieprawidłowe w klasach statycznych.

Dla domyślnych wartości, jeśli nie umieścisz modyfikatora dostępu z przodu, zobacz tutaj:
domyślna widoczność dla klas i członków C# (pól, metod, itp.)?

Nested

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żony:

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

Jest też sealed-słowo kluczowe, które sprawia, że klasa nie jest dziedziczona.
Również w VB.NET, słowa kluczowe są czasami różne, więc tutaj Ściągawka:

Public - Jeśli widzisz klasę, to możesz zobaczyć metodę

Private - Jeśli jesteś częścią klasy, to możesz zobaczyć metodę, w przeciwnym razie nie.

Protected - tak samo jak Private, plus wszystkiepotomkowie mogą również zobaczyć metodę.

Static (class) - pamiętasz rozróżnienie między "Class" I "Object"? Zapomnij o tym. Są takie same z "static"... klasa jest jedyną instancją siebie.

Static (method) - ilekroć użyjesz tej metody, będzie ona miała ramkę odniesienia niezależną od rzeczywistej instancji klasy, której jest częścią.

Reposting the awesome diagrams from this answer .

Oto wszystkie modyfikatory dostępu na diagramach Venna, od bardziej ograniczającego do bardziej rozwiązłego:

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 Nic

• typy przestrzeni nazw są domyślnie wewnętrzne
• każdy członek typu, w tym zagnieżdżone typy są domyślnie prywatne

Yet another visual approach of the current access modifier (C# 7.2). Mam nadzieję, że schemat pomaga zapamiętać go łatwiej
_{(Kliknij obraz, Aby wyświetlić interaktywny widok.)}

Na Zewnątrz Wewnątrz

Jeśli masz problemy z zapamiętaniem dwu wyrazowych modyfikatorów dostępu, pamiętaj outside-inside.

• private protected: prywatne outside (ten sam zespół) protected wewnątrz (ten sam montaż)
• chronione wewnętrzne: protected zewnętrzne (ten sam zespół) wewnętrzne wewnątrz (ten sam montaż)

Hmm.

Zobacz tutaj: modyfikatory dostępu .

W skrócie:

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

Private zezwala tylko typowi zawierającemu prywatną metodę/zmienną na dostęp do prywatnej metody / zmiennej (zauważ, że zagnieżdżone klasy mają również dostęp do zawierających ją klas prywatnych metod / zmiennych).

Protected jest podobny do private, z tym że klasy pochodne mogą również uzyskać dostęp do protected metody.

" nic " jest VB.NET jest odpowiednikiem null. Chociaż jeśli mówisz o "nic", co oznacza "brak modyfikatora dostępu", To zależy, chociaż bardzo ogólną zasadą (na pewno w C#) jest to, że jeśli nie określisz bezpośrednio modyfikatora dostępu, deklaracja metody/zmiennej jest zwykle jako restricted, Jak to tylko możliwe. tj.

public class MyClass
{
    string s = "";
}

Jest dokładnie tym samym co:

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

Połączony artykuł MSDN będzie oferował pełny opis, gdy nie ma dostępu modyfikator jawnie określony.

Public - może być dostępny dla każdego w dowolnym miejscu.
private - można uzyskać dostęp tylko z klasy, której jest częścią.
protected - można uzyskać dostęp tylko z with in klasy lub dowolnego obiektu, który dziedziczy poza klasą.

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

Mmm...

Statyczne 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 Private wskazuje, że zmienne mogą być dostępne tylko przez obiekty tej samej klasy. Protected status rozszerza ten dostęp również o Potomków klasy.

" z powyższej tabeli widzimy zależność pomiędzy private I protected... myślę, że oba są takie same.... więc po co te dwa oddzielne polecenia "

Sprawdź MSDN link, aby uzyskać więcej informacji

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

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

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

Ponadto Microsoft nie jest zbyt wyraźny w pokazywaniu modyfikatorów dostępu (publicznych, chronionych itp.. słowa kluczowe) przy tworzeniu nowych klas w Visual Studio. Dbaj więc o dostępność swojej klasy, ponieważ jest to drzwi do wewnętrznych wdrożeń.

Myślę, że jest to związane z dobrym projektem OOP. Jeśli jesteś twórcą biblioteki, chcesz ukryć wewnętrzne działanie swojej biblioteki. W ten sposób możesz później zmodyfikować wewnętrzne działanie biblioteki. Więc umieszczasz swoje metody Member i helper jako prywatne, a tylko metody interfejsu są publiczne. Metody, które powinny być nadpisane powinny być chronione.

C # ma w sumie, 6 modyfikatory dostępu:

Private: Element zadeklarowany z tą dostępnością może być widoczny w typie zawierającym, nie jest widoczny dla żadnych typów pochodnych, innych typów w tym samym złożeniu lub typów poza złożeniem zawierającym. tzn. dostęp jest ograniczony tylko do typu zawierającego.

Protected: Element zadeklarowany z tą dostępnością może być widoczny w typach pochodzących z containing Typ wewnątrz zespołu zawierającego oraz typy pochodzące z typu zawierającego poza zespołem zawierającym. tzn. dostęp jest ograniczony do typów pochodnych typu zawierającego.

Internal: Element zadeklarowany z tą dostępnością może być widoczny w zestawie zawierającym ten element, nie jest widoczny dla żadnego zestawu poza zestawem zawierającym. tzn. dostęp jest ograniczony tylko do złożenia.

Wewnętrzne protected: Element zadeklarowany z tą dostępnością może być widoczny w typach pochodzących z typu zawierającego wewnątrz lub poza złożeniem zawierającym, jest również widoczny dla wszystkich typów w złożeniu zawierającym. tzn. dostęp jest ograniczony do typów składowych lub pochodnych.

Public : członek zadeklarowany z tą dostępnością może być widoczny w Zgromadzeniu zawierającym tego członka, lub w każdym innym zgromadzeniu, które odwołuje się do zawierającego montaż. tj. dostęp nie jest ograniczony.

W C # 7.2 dodano nowy poziom dostępności:

Private protected: Element zadeklarowany z tą dostępnością może być widoczny w typach wywodzących się z tego typu zawierającego w zestawie zawierającym. Nie jest widoczny dla żadnych typów, które nie pochodzą z typu zawierającego lub poza zespołem zawierającym. tj. dostęp jest ograniczony do typów pochodnych w obrębie montaż.

Źródło zawierające przykładowy kod nowego modyfikatora private protected access

Wszystkie opisy modyfikatorów dostępu do C #