Quali sono i modificatori di accesso predefiniti in C #?

Qual è il modificatore di accesso predefinito per classi, metodi, membri, costruttori, delegati e interfacce?

L’accesso predefinito per tutto in C # è “l’accesso più limitato che potresti dichiarare per quel membro” .

Quindi per esempio:

namespace MyCompany { class Outer { void Foo() {} class Inner {} } } 

è equivalente a

 namespace MyCompany { internal class Outer { private void Foo() {} private class Inner {} } } 

L’unico tipo di eccezione a questo è rendere una parte di una proprietà (di solito il setter) più limitata rispetto all’accessibilità dichiarata della proprietà stessa:

 public string Name { get { ... } private set { ... } // This isn't the default, have to do it explicitly } 

Questo è quanto afferma la specifica C # 3.0 (sezione 3.5.1):

A seconda del contesto in cui si verifica una dichiarazione membro, sono consentiti solo determinati tipi di accessibilità dichiarata. Inoltre, quando una dichiarazione membro non include alcun modificatore di accesso, il contesto in cui avviene la dichiarazione determina l’accessibilità dichiarata predefinita.

  • Gli spazi dei nomi implicitamente hanno accessibilità dichiarata pubblica. Nessun modificatore di accesso è consentito sulle dichiarazioni dello spazio dei nomi.
  • I tipi dichiarati nelle unità di compilazione o negli spazi dei nomi possono avere accessibilità dichiarata pubblica o interna e sono predefiniti all’accessibilità dichiarata interna.
  • I membri della class possono avere uno qualsiasi dei cinque tipi di accessibilità dichiarata e di default all’accessibilità dichiarata privata. (Si noti che un tipo dichiarato come membro di una class può avere uno qualsiasi dei cinque tipi di accessibilità dichiarata, mentre un tipo dichiarato come membro di uno spazio dei nomi può avere solo accessibilità pubblica o interna dichiarata).
  • I membri di Struct possono avere accessibilità dichiarata pubblica, interna o privata e l’impostazione predefinita all’accessibilità dichiarata privata perché le strutture sono implicitamente sigillate. I membri di Struct introdotti in una struct (cioè non ereditati da quella struttura) non possono avere accessibilità dichiarata interna protetta o protetta. (Si noti che un tipo dichiarato come membro di una struct può avere accessibilità dichiarata pubblica, interna o privata, mentre un tipo dichiarato come membro di uno spazio dei nomi può avere solo accessibilità pubblica o interna dichiarata).
  • I membri dell’interfaccia implicitamente hanno accessibilità dichiarata pubblica. Nessun modificatore di accesso è consentito sulle dichiarazioni dei membri dell’interfaccia.
  • I membri di enumerazione implicitamente hanno accesso pubblico dichiarato. Nessun modificatore di accesso è consentito sulle dichiarazioni dei membri di enumerazione.

(Si noti che i tipi annidati rientrerebbero nelle parti “membri della class” o “membri della struct” e quindi di default nella visibilità privata.)

 top level class: internal method: private members (unless an interface or enum): private (including nested classs) members (of interface or enum): public constructor: private (note that if no constructor is explicitly defined, a public default constructor will be automatically defined) delegate: internal interface: internal explicitly implemented interface member: public! 

Risposta breve: accesso minimo ansible (cfr. Risposta di Jon Skeet).

Risposta lunga:

Tipi non annidati , accessi di elenchi e delegati ( possono avere solo accessibilità interna o pubblica )

  | Default | Permitted declared accessibilities ------------------------------------------------------------------ namespace | public | none (always implicitly public) enum | public | none (always implicitly public) interface | internal | public, internal class | internal | public, internal struct | internal | public, internal delegate | internal | public, internal 

Tipo nidificato e accessibilità dei membri

  | Default | Permitted declared accessibilities ------------------------------------------------------------------ namespace | public | none (always implicitly public) enum | public | none (always implicitly public) interface | public | none class | private | All¹ struct | private | public, internal, private² delegate | private | All¹ constructor | private | All¹ interface member | public | none (always implicitly public) method | private | All¹ field | private | All¹ user-defined operator| none | public (must be declared public) 

¹ Tutto === interno pubblico, protetto, interno, privato, protetto

² le strutture non possono ereditare da strutture o classi (anche se possono, interfacce), quindi protetto non è un modificatore valido

L’accessibilità di un tipo annidato dipende dal suo dominio di accessibilità, che è determinato sia dall’accessibilità dichiarata del membro sia dal dominio di accessibilità del tipo immediatamente contenente. Tuttavia, il dominio di accessibilità di un tipo annidato non può superare quello del tipo contenente.

Nota: CIL ha anche la clausola di protezione interna e protetta (al contrario di quella già esistente “o” interna “), ma a mia conoscenza questo non è attualmente disponibile per l’uso in C #.


Vedere:

http://msdn.microsoft.com/en-us/library/ba0a1yw2.aspx
http://msdn.microsoft.com/en-us/library/ms173121.aspx
http://msdn.microsoft.com/en-us/library/cx03xt0t.aspx
(Man I love Microsoft URIs …)

Dai un’occhiata a Modificatori di accesso (C # Programming Guide)

Accessibilità di class e di condotta
Internal è l’impostazione predefinita se non viene specificato alcun modificatore di accesso.

Accessibilità per membri di Class and Struct
I membri della class (comprese le classi e le strutture nidificate) possono essere dichiarati con uno dei cinque tipi di accesso. I membri di Struct non possono essere dichiarati come protetti perché le strutture non supportano l’ereditarietà.

L’accessibilità di un membro non può mai essere maggiore dell’accessibilità del suo tipo di contenuto

Gli operatori definiti dall’utente devono sempre essere dichiarati come pubblici. Per ulteriori informazioni, vedere operatore (Riferimento C #).

I distruttori non possono avere modificatori di accessibilità.

Altri tipi
Le interfacce dichiarate direttamente con uno spazio dei nomi possono essere dichiarate come pubbliche o interne e come classi e strutture, le interfacce predefinite per l’accesso interno.

I membri di enumerazione sono sempre pubblici e non è ansible applicare alcun modificatore di accesso.

Per impostazione predefinita, i delegati hanno accesso interno.

Vorrei aggiungere un link alla documentazione. Scopri maggiori dettagli qui .

inserisci la descrizione dell'immagine qui

Internal è il modificatore predefinito

Livello di spazio dei nomi: internal

Tipo di livello: private