Quais são os modificadores de acesso padrão em C #?

Qual é o modificador de acesso padrão para classes, métodos, membros, construtores, delegados e interfaces?

O acesso padrão para tudo em C # é "o acesso mais restrito que você pode declarar para esse membro" .

Então, por exemplo:

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

é equivalente a

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

O único tipo de exceção a isso é tornar uma parte de uma propriedade (geralmente o setter) mais restrita do que a acessibilidade declarada da própria propriedade:

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

Isto é o que a especificação do C # 3.0 tem a dizer (seção 3.5.1):

Dependendo do contexto em que uma declaração de membro ocorre, apenas certos tipos de acessibilidade declarada são permitidos. Além disso, quando uma declaração de membro não inclui nenhum modificador de acesso, o contexto em que a declaração ocorre determina a acessibilidade declarada padrão.

• Os espaços para nome implicitamente têm acessibilidade declarada pública. Nenhum modificador de acesso é permitido nas declarações do espaço para nome.
• Os tipos declarados em unidades de compilação ou espaços de nome podem ter acessibilidade declarada pública ou interna e usar como padrão a acessibilidade declarada interna.
• Os membros da classe podem ter qualquer um dos cinco tipos de acessibilidade declarada e usar como padrão a acessibilidade declarada privada. (Observe que um tipo declarado como membro de uma classe pode ter qualquer um dos cinco tipos de acessibilidade declarada, enquanto um tipo declarado como membro de um espaço para nome pode ter apenas acessibilidade declarada pública ou interna.)
• Os membros do Struct podem ter acessibilidade declarada pública, interna ou privada e usar como padrão a acessibilidade declarada privada porque as estruturas são implicitamente seladas. Os membros de estrutura introduzidos em uma estrutura (isto é, não são herdados por essa estrutura) não podem ter acessibilidade declarada interna protegida ou protegida. (Observe que um tipo declarado como membro de uma estrutura pode ter acessibilidade declarada pública, interna ou privada, enquanto um tipo declarado como membro de um espaço para nome pode ter apenas acessibilidade declarada pública ou interna.)
• Os membros da interface implicitamente têm acessibilidade declarada pública. Nenhum modificador de acesso é permitido nas declarações dos membros da interface.
• Os membros da enumeração implicitamente têm acessibilidade declarada pública. Nenhum modificador de acesso é permitido nas declarações dos membros da enumeração.

(Observe que os tipos aninhados seriam incluídos nas partes "class members" ou "struct members" - e, portanto, usarão como padrão a visibilidade 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!

Resposta curta: acesso mínimo possível (cf. resposta de Jon Skeet).

Resposta longa:

Tipos não aninhados , enumeração e delegação de acessibilidade ( podem ter apenas acessibilidade interna ou 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

Acessibilidade de tipo e membro aninhado

                     | 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

As estruturas ² não podem herdar de estruturas ou classes (embora possam, interfaces); portanto, protected não é um modificador válido

A acessibilidade de um tipo aninhado depende de seu domínio de acessibilidade, que é determinado pela acessibilidade declarada do membro e pelo domínio de acessibilidade do tipo que contém imediatamente. No entanto, o domínio de acessibilidade de um tipo aninhado não pode exceder o domínio do tipo que o contém.

Nota: O CIL também possui a provisão para protegido e interno (em oposição ao existente protegido "ou" interno), mas, pelo que sei, isso não está disponível atualmente para uso em C #.

Vejo:

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
(Homem que eu amo URIs da Microsoft ...)

Dê uma olhada em Modificadores de acesso (Guia de Programação em C #)

Acessibilidade de classe e estrutura

Classes e estruturas que são declaradas diretamente em um espaço para nome (em outras palavras, que não estão aninhadas em outras classes ou estruturas) podem ser públicas ou internas. Interno é o padrão se nenhum modificador de acesso for especificado.

Os membros do Struct, incluindo classes e estruturas aninhadas, podem ser declarados como públicos, internos ou privados. Os membros da classe, incluindo classes e estruturas aninhadas, podem ser públicos, internos protegidos, protegidos, internos, privados ou privados. O nível de acesso para membros da classe e membros da estrutura, incluindo classes e estruturas aninhadas, é privado por padrão. Tipos aninhados privados não são acessíveis de fora do tipo que contém.

Classes derivadas não podem ter maior acessibilidade que seus tipos básicos. Em outras palavras, você não pode ter uma classe pública B derivada de uma classe interna A. Se isso fosse permitido, isso teria o efeito de tornar pública A, porque todos os membros internos ou protegidos de A são acessíveis a partir da classe derivada.

Você pode ativar outros assemblies específicos para acessar seus tipos internos usando o InternalsVisibleToAttribute. Para mais informações, consulte Assembléias de amigos.

Acessibilidade para membros de classe e estrutura

Os membros da classe (incluindo classes e estruturas aninhadas) podem ser declarados com qualquer um dos seis tipos de acesso. Os membros do Struct não podem ser declarados como protegidos porque as estruturas não suportam herança.

Normalmente, a acessibilidade de um membro não é maior que a acessibilidade do tipo que o contém. No entanto, um membro público de uma classe interna pode estar acessível de fora do assembly se o membro implementar métodos de interface ou substituir métodos virtuais definidos em uma classe base pública.

O tipo de qualquer membro que é um campo, propriedade ou evento deve ser pelo menos tão acessível quanto o próprio membro. Da mesma forma, o tipo de retorno e os tipos de parâmetro de qualquer membro que seja um método, indexador ou delegado devem ser pelo menos tão acessíveis quanto o próprio membro. Por exemplo, você não pode ter um método público M que retorne uma classe C, a menos que C também seja público. Da mesma forma, você não pode ter uma propriedade protegida do tipo A se A for declarada como privada.

Operadores definidos pelo usuário sempre devem ser declarados como públicos e estáticos. Para mais informações, consulte Sobrecarga do operador.

Os finalizadores não podem ter modificadores de acessibilidade.

Outros tipos

As interfaces declaradas diretamente em um espaço para nome podem ser declaradas como públicas ou internas e, assim como classes e estruturas, as interfaces são padrão para o acesso interno. Os membros da interface são sempre públicos porque o objetivo de uma interface é permitir que outros tipos acessem uma classe ou estrutura. Nenhum modificador de acesso pode ser aplicado aos membros da interface.

Os membros da enumeração são sempre públicos e nenhum modificador de acesso pode ser aplicado.

Os delegados se comportam como classes e estruturas. Por padrão, eles têm acesso interno quando declarado diretamente em um espaço para nome e acesso privado quando aninhado.

Classe é Interna por padrão.

• Os membros da classe são privados por padrão.

A interface é Interna por padrão.

• Os membros da interface são públicos por padrão. (As interfaces não nos permitem especificar nenhum tipo de acessibilidade para seus membros.)

  Nota: Se você tentar especificar qualquer especificador de acesso para os membros da interface, isso mostrará um erro de compilação.

Struct é Interno por padrão.

• Os membros do Struct são privados por padrão.

Eu gostaria de adicionar algum link de documentação. Confira mais detalhes aqui .

A resposta mais simples é a seguinte .....

Todos os membros em C # sempre usam o modificador acessível LEAST possível por padrão.

É por isso que todas as classes de nível superior em uma montagem são "internas" por padrão, o que significa que elas são públicas na montagem em que estão, mas são privadas ou excluídas do acesso a montagens externas. A única outra opção para uma classe de nível superior é pública, mais acessível. Para tipos aninhados, tudo é privado, exceto por algumas raras exceções, como membros de enumerações e interfaces que só podem ser públicas. Alguns exemplos. No caso de classes e interfaces de nível superior, os padrões são:

classe Animal igual à classe interna Animal

Interface Animal igual à interface pública Animal

No caso de classes e interfaces aninhadas (tipos internos), os padrões são:

classe Animal igual à classe privada Animal

interface Animal igual à interface privada Animal

Se você apenas assumir que o padrão é sempre o mais privado, não precisará usar um acessador até precisar alterar o padrão. Fácil.

Internal é o modificador padrão

Nível do espaço para nome: internal

Nível do tipo: private