Jaka jest różnica między publicznym, prywatnym, chronionym i nie mającym modyfikatora dostępu?

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ą.

Graficzny przegląd (podsumowanie w skrócie)

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

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

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.

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.

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:

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ę.

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

Również Microsoft nie jest zbyt dobry w pokazywaniu modyfikatorów dostępu (public, protected, etc.. słowa kluczowe) przy tworzeniu nowych klas w Visual Studio. Tak więc, dbaj o siebie i pomyśl o dostępności 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 wywodzących się z typu zawierającego w zespół zawierający 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ętrzny protected : członek zadeklarowany z tym dostępność może być widoczna w typach pochodzących z typu zawierającego wewnątrz lub na zewnątrz zespołu zawierającego, jest również widoczna dla wszystkich typów w zespole 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 Zgromadzenia zawierającego. tj. dostęp nie jest ograniczony.

C # 7.2 jest dodanie nowego poziomu 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. tzn. dostęp jest ograniczony do typów pochodnych w składni zawierającej.

Źródło wraz z przykładowym kodem nowego prywatnego dostępu chronionego modyfikator