¿Cuáles son los modificadores de acceso predeterminados en C #?

¿Cuál es el modificador de acceso predeterminado para clases, métodos, miembros, constructores, delegates e interfaces?

El acceso predeterminado para todo en C # es “el acceso más restringido que puede declarar para ese miembro” .

Así por ejemplo:

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

es equivalente a

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

El único tipo de excepción a esto es hacer que una parte de una propiedad (por lo general, la incubadora) sea más restringida que la accesibilidad declarada de la propiedad en sí misma:

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

Esto es lo que la especificación de C # 3.0 tiene que decir (sección 3.5.1):

Dependiendo del contexto en el que tiene lugar la statement de un miembro, solo se permiten ciertos tipos de accesibilidad declarada. Además, cuando una statement miembro no incluye ningún modificador de acceso, el contexto en el que tiene lugar la statement determina la accesibilidad declarada predeterminada.

  • Los espacios de nombres tienen implícitamente acceso público declarado. No se permiten modificadores de acceso en las declaraciones de espacios de nombres.
  • Los tipos declarados en unidades de comstackción o espacios de nombres pueden tener accesibilidad pública o interna declarada y acceso predeterminado declarado interno.
  • Los miembros de la clase pueden tener cualquiera de los cinco tipos de accesibilidad declarada y el acceso predeterminado declarado privado. (Tenga en cuenta que un tipo declarado como miembro de una clase puede tener cualquiera de los cinco tipos de accesibilidad declarada, mientras que un tipo declarado como miembro de un espacio de nombre solo puede tener acceso público o declarado declarado).
  • Los miembros de Struct pueden tener acceso público, interno o privado declarado y acceso predeterminado a privado declarado porque las estructuras están implícitamente selladas. Los miembros de Struct introducidos en una estructura (es decir, no heredados por esa estructura) no pueden tener protegida o protegida la accesibilidad declarada interna. (Tenga en cuenta que un tipo declarado como miembro de una estructura puede tener accesibilidad declarada pública, interna o privada, mientras que un tipo declarado como miembro de un espacio de nombre solo puede tener acceso público o declarado declarado).
  • Los miembros de la interfaz tienen implícitamente acceso público declarado. No se permiten modificadores de acceso en las declaraciones de los miembros de la interfaz.
  • Los miembros de enumeración tienen implícitamente acceso público declarado. No se permiten modificadores de acceso en las declaraciones de miembros de enumeración.

(Tenga en cuenta que los tipos nesteds se incluirían en las partes “miembros de la clase” o “miembros de la estructura” y, por lo tanto, se definirán por defecto en visibilidad privada).

 top level class: internal method: private members (unless an interface or enum): private (including nested classes) 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! 

Respuesta corta: acceso mínimo posible (véase la respuesta de Jon Skeet).

Respuesta larga:

Accesibilidad de tipos no enumerados, enumeración y delegado ( solo puede tener acceso interno o público )

  | 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 nested y acceso de los miembros

  | 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) 

¹ Todos === público, protegido, interno, privado, protegido interno

² las estructuras no pueden heredar de estructuras o clases (aunque pueden, interfaces), por lo tanto, protegido no es un modificador válido

La accesibilidad de un tipo nested depende de su dominio de accesibilidad, que está determinado tanto por la accesibilidad declarada del miembro como por el dominio de accesibilidad del tipo que lo contiene inmediatamente. Sin embargo, el dominio de accesibilidad de un tipo nested no puede exceder el del tipo contenedor.

Nota: CIL también tiene la provisión de protección e interna (a diferencia de la protección existente “o” interna), pero que yo sepa, esto no está actualmente disponible para su uso en C #.


Ver:

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
(Hombre me encantan los URI de Microsoft …)

Eche un vistazo a los modificadores de acceso (Guía de progtwigción C #)

Accesibilidad de clase y estructura
Internal es el valor predeterminado si no se especifica ningún modificador de acceso.

Accesibilidad para miembros de clase y estructura
Los miembros de la clase (incluidas las clases y las estructuras anidadas) se pueden declarar con cualquiera de los cinco tipos de acceso. Los miembros de Struct no se pueden declarar como protegidos porque las estructuras no admiten la herencia.

La accesibilidad de un miembro nunca puede ser mayor que la accesibilidad de su tipo contenedor

Los operadores definidos por el usuario siempre deben declararse como públicos. Para obtener más información, consulte operador (Referencia C #).

Los destructores no pueden tener modificadores de accesibilidad.

Otros tipos
Las interfaces declaradas directamente con un espacio de nombres pueden declararse como públicas o internas y, al igual que las clases y las estructuras, las interfaces tienen por defecto el acceso interno.

Los miembros de enumeración son siempre públicos, y no se pueden aplicar modificadores de acceso.

Por defecto, los delegates tienen acceso interno.

Me gustaría agregar algún enlace de documentación. Vea más detalles aquí .

enter image description here

Internal es el modificador predeterminado

Nivel de espacio de nombres: internal

Tipo de nivel: private