niveles - ¿Cuáles son los modificadores de acceso predeterminados en C#?
public c# (9)
Eche un vistazo a los http://msdn.microsoft.com/en-us/library/ms173121.aspx
Clase y accesibilidad
Interno es el valor predeterminado si no se especifica ningún modificador de acceso.Clase y Accesibilidad para Miembros
Los miembros de la clase (incluidas las clases y 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 que contiene
Los operadores definidos por el usuario siempre deben ser declarados como públicos. Para más información, ver operador (Referencia C #).
Los destructores no pueden tener modificadores de accesibilidad.
Otros tipos
Las interfaces declaradas directamente con un espacio de nombres se pueden declarar como públicas o internas y clases y estructuras similares, las interfaces predeterminadas al acceso interno.Los miembros de la enumeración son siempre públicos y no se pueden aplicar modificadores de acceso.
Por defecto, los delegados tienen acceso interno.
¿Cuál es el modificador de acceso predeterminado para clases, métodos, miembros, constructores, delegados e interfaces?
El acceso predeterminado para todo en C # es "el acceso más restringido que podría 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 (generalmente el establecedor) sea más restringida que la accesibilidad declarada de la propiedad en sí:
public string Name
{
get { ... }
private set { ... } // This isn''t the default, have to do it explicitly
}
Esto es lo que la especificación C # 3.0 tiene que decir (sección 3.5.1):
Dependiendo del contexto en el que se lleva a cabo una declaración de miembro, solo se permiten ciertos tipos de accesibilidad declarada. Además, cuando una declaración de miembro no incluye ningún modificador de acceso, el contexto en el que se lleva a cabo la declaración 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 espacio de nombres.
- Los tipos declarados en unidades de compilación o espacios de nombres pueden tener accesibilidad declarada pública o interna y por defecto a la accesibilidad declarada interna.
- Los miembros de la clase pueden tener cualquiera de los cinco tipos de accesibilidad declarada y por defecto a la accesibilidad declarada privada. (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 nombres solo puede tener accesibilidad declarada pública o interna).
- Los miembros de Struct pueden tener accesibilidad declarada pública, interna o privada y por defecto a accesibilidad declarada privada porque las estructuras están selladas implícitamente. Los miembros de Struct introducidos en una estructura (es decir, no heredados por esa estructura) no pueden tener una accesibilidad declarada interna protegida o protegida. (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 nombres solo puede tener accesibilidad declarada pública o interna).
- Los miembros de la interfaz tienen implícitamente acceso público declarado. No se permiten modificadores de acceso en las declaraciones de miembros de la interfaz.
- Los miembros de la 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 anidados se incluirán en las partes de "miembros de la clase" o "miembros de la estructura" y, por lo tanto, el valor predeterminado será visibilidad privada).
Interno es el modificador por defecto
La clase es interna por defecto.
- Los miembros de la clase son privados por defecto.
La interfaz es interna por defecto.
Los miembros de la interfaz son públicos por defecto. (Las interfaces no nos permitirán especificar ningún tipo de accesibilidad para sus miembros).
Nota: Si intenta especificar algún especificador de acceso para los miembros de la interfaz, se mostrará un error de compilación.
Struct es interno por defecto.
- Los miembros de Struct son privados por defecto.
La respuesta más simple es la siguiente ...
Todos los miembros en C # siempre toman el modificador accesible MENOS posible de forma predeterminada.
Es por eso que todas las clases de nivel superior en un conjunto son "internas" por defecto, lo que significa que son públicas para el conjunto en el que están, pero privadas o excluidas del acceso a conjuntos externos. La única otra opción para una clase de nivel superior es pública, que es más accesible. Para los tipos anidados, todo es privado, excepto por algunas raras excepciones, como miembros de enumeraciones e interfaces que solo pueden ser públicas. Algunos ejemplos. En el caso de las clases e interfaces de nivel superior, los valores predeterminados son:
clase animal igual que clase interna animal
interfaz animal igual que interfaz pública animal
En el caso de clases e interfaces anidadas (tipos internos), los valores predeterminados son:
clase animal igual que clase privada animal
interfaz animal igual que interfaz privada animal
Si simplemente asume que el valor predeterminado es siempre el más privado, no necesita usar un dispositivo de acceso hasta que necesite cambiar el valor predeterminado. Fácil.
Me gustaría añadir algún enlace de documentación. Echa un vistazo a más detalles here .
Nivel de espacio de nombres: internal
Tipo de nivel: private
Respuesta corta: acceso mínimo posible (ver la respuesta de Jon Skeet).
Respuesta larga:
Tipos no anidados , enumeración y accesibilidad de delegados ( puede que solo tengan accesibilidad interna o pública )
| 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 anidado y accesibilidad de 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úblicos, protegidos, internos, privados, protegidos internos
Las estructuras ² no pueden heredar de estructuras o clases (aunque sí pueden, interfaces), por lo que protegido no es un modificador válido
La accesibilidad de un tipo anidado 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 contiene inmediatamente. Sin embargo, el dominio de accesibilidad de un tipo anidado no puede exceder el del tipo que contiene.
Nota: CIL también tiene la provisión para protegido e interno (a diferencia del existente protegido o interno), pero que yo sepa, actualmente no está 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
(El hombre me encanta Microsoft URIs ...)
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!