Qual è la differenza tra public, private, protected e having no access modifier?

Public - Se riesci a vedere la classe, allora puoi vedere il metodo

Private - Se sei parte di della classe, allora puoi vedere il metodo, altrimenti no.

Protetto - Come Privato, più tutti discendenti possono anche vedere il metodo.

Static (class) - Ricorda la distinzione tra "Class" e "Object" ? Lascia perdere tutto questo. Sono gli stessi con "static"... la classe è l'unica istanza di stesso.

Static (method) - Ogni volta che si utilizza questo metodo, avrà un frame di riferimento indipendente dall'istanza effettiva della classe di cui fa parte.

Una panoramica grafica (sintesi in poche parole)

Per i valori predefiniti se non si mette alcun modificatore di accesso davanti, vedere qui:
Visibilità predefinita per classi e membri c# (campi, metodi, ecc.)?

Non nidificato

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

Nidificato:

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

Per quanto riguarda la domanda di Niente

• I tipi di spazio dei nomi sono interni per impostazione predefinita
• Qualsiasi membro del tipo, inclusi i tipi nidificati, è privato per impostazione predefinita

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.

Vedi qui: Modificatori di accesso .

In poche parole:

Public fornisce al metodo o al tipo una visibilità completa da altri tipi / classi.

Private consente solo al tipo contenente il metodo privato/variabile di accedere al metodo privato/variabile (si noti che le classi nidificate hanno anche accesso alle classi contenenti metodi/variabili private).

Protected è simile a private tranne che le classi derivate possono anche accedere a protected metodo.

"Niente" è VB.NET ' s equivalente a null. Anche se ti riferisci a "niente" che significa "nessun modificatore di accesso", allora dipende, anche se una regola empirica molto approssimativa (certamente in c#) è che se non si specifica esplicitamente un modificatore di accesso, la dichiarazione del metodo/variabile è di solito come restricted come può essere. cioè

public class MyClass
{
    string s = "";
}

È effettivamente lo stesso di:

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

L'articolo MSDN collegato offrirà una descrizione completa quando non c'è accesso modificatore specificato esplicitamente.

Public - può essere accessibile da chiunque ovunque.
privato - è possibile accedere solo da with nella classe di cui fa parte.
protected - è possibile accedere solo da with nella classe o da qualsiasi oggetto che eredita dalla classe.

Niente è come null ma in VB.
Static significa che hai un'istanza di quell'oggetto, metodo per ogni istanza di quella classe.

Ripubblicando i diagrammi impressionanti da questa risposta.

Ecco tutti i modificatori di accesso nei diagrammi di Venn, da più limitanti a più promiscui:

private:

private protected: - aggiunto in C# 7.2

internal:

protected:

protected internal:

public:

Mmm...

Static significa che è possibile accedere a tale funzione senza avere un'istanza della classe.

È possibile accedere direttamente dalla definizione della classe.

Uno stato di Privato indica che le variabili possono essere accessibili solo da oggetti della stessa classe. Lo stato protetto estende tale accesso anche ai discendenti della classe.

"dalla tabella sopra possiamo vedere la deferenza tra privato e protetto... penso che entrambi siano uguali.... quindi qual è la necessità di quei due comandi separati "

Controllare MSDN collegamento per ulteriori informazioni

Questi modificatori di accesso specificano dove sono visibili i tuoi membri. Probabilmente dovresti leggere questo. Prendi il link dato da IainMH come punto di partenza.

I membri statici sono uno per classe e non uno per istanza.

Fai attenzione alla tua accessibilità delle tue classi. Le classi e i metodi pubblici e protetti sono di default accessibili a tutti.

Inoltre Microsoft non è molto esplicita nel mostrare i modificatori di accesso (pubblico, protetto, ecc.. parole chiave) quando vengono create nuove classi in Visual Studio. Quindi, fai attenzione e pensa alla tua accessibilità della tua classe perché è la porta per i tuoi interni di implementazione.

Penso che sia legato al buon design OOP. Se sei uno sviluppatore di una libreria, vuoi nascondere il funzionamento interno della tua libreria. In questo modo, è possibile modificare il funzionamento interno della libreria in seguito. Quindi metti i tuoi membri e i metodi di supporto come privati, e solo i metodi di interfaccia sono pubblici. I metodi che devono essere sovrascritti devono essere protetti.

C # ha in totale 6 modificatori di accesso:

Private: il membro dichiarato con questa accessibilità può essere visibile all'interno del tipo contenente, non è visibile a nessun tipo derivato, ad altri tipi nello stesso assembly o tipi al di fuori dell'assembly contenente. cioè, l'accesso è limitato al solo tipo contenente.

Protetto: il membro dichiarato con questa accessibilità può essere visibile all'interno dei tipi derivati dal tipo contenente all'interno del assieme contenente e i tipi derivati dal tipo contenente al di fuori dell'assieme contenente. cioè, l'accesso è limitato ai tipi derivati del tipo contenente.

Interno: il membro dichiarato con questa accessibilità può essere visibile all'interno dell'assembly contenente questo membro, non è visibile a nessun assembly al di fuori dell'assembly contenente. cioè, l'accesso è limitato a contenere solo assembly.

Interno protetto: Il membro dichiarato con questo l'accessibilità può essere visibile all'interno dei tipi derivati dal tipo contenente all'interno o all'esterno dell'assembly contenente, è visibile anche a qualsiasi tipo all'interno dell'assembly contenente. cioè, l'accesso è limitato a contenere tipi di assembly o derivati.

Public: il membro dichiarato con questa accessibilità può essere visibile all'interno dell'assembly contenente questo membro o qualsiasi altro assembly che fa riferimento all'assembly contenente. cioè, l'accesso non è limitato.

C # 7.2 è aggiunta di un nuovo livello di accessibilità:

Private protected : il membro dichiarato con questa accessibilità può essere visibile all'interno dei tipi derivati da questo tipo contenente all'interno dell'assembly contenente. Non è visibile a nessun tipo non derivato dal tipo contenente o all'esterno dell'assembly contenente. cioè, l'accesso è limitato ai tipi derivati all'interno dell'assembly contenente.

Fonte incluso un codice di esempio del nuovo accesso privato protetto modificatore