Como faço para implementar membros de interfaces internas

Question

Eu tenho refatoração do código base do projeto que eu estou atualmente em assim que as classes / interfaces que não são úteis para além dos limites da Assembleia deve ser declarado como interna (em vez de público). Mas eu correr em um problema com o seguinte código:

internal interface IFirstInterface
{
    ...
}

internal interface ISecondInterface
{
    IFirstInterface First{ get; }
    ...
}

public class Implementer : ISecondInterface
{
    public IFirstInterface First {get; private set;}
    ...
}

As minhas perguntas:

1. Por que membros de interfaces internas têm de ser implementadas publicamente? Se você implementar a interface em uma classe interna, não devem os membros implementados ser interno? Este não é um grande problema já que os membros de interface não será de qualquer maneira acessível ao público, dada a classe é interno. Parece apenas contra-intuitivo.

2. O principal problema é com o cenário acima desde que eu não posso ter um getter público para IFirstInterface uma vez que é supostamente um interno de interface ou seja, eu recebo o seguinte erro do compilador:

Acessibilidade inconsistente: propriedade tipo 'IFirstInterface' é menos acessíveis do imóvel 'Implementer.First'

Existe alguma maneira de contornar isso?

Nota :. Eu percebo que há provavelmente pouco valor neste exercício refatoração, mas eu pensei que seria uma boa maneira para eu entender mais profundamente as implicações do modificador interno

Answer 1

Apenas a nota - o código que você realmente fornecido faz de compilação, porque Implementer é uma classe interna. O problema surge quando Implementer é pública.

A forma redonda isso é usar implementação de interface explícita:

public class Implementer : ISecondInferface
{
    private IFirstInterface first;
    IFirstInterface ISecondInterface.First { get { return first; } }
}

Você não pode ter o setter lá, porque você está implementando explicitamente a interface que não define o setter. Você poderia fazer isso como uma alternativa:

public class Implementer : ISecondInterface
{
    internal IFirstInterface First { get; private set; }
    IFirstInterface ISecondInterface.First { get { return First; } }
}

É lamentável que as interfaces internas tem membros públicos - ele faz coisas complicar assim. Seria estranho para uma interface pública para ter um membro interno (o que seria interna para -? O executor ou o declarante). Mas para interfaces internas que faz muito mais sentido

Answer 2

Por que os membros de interfaces internas têm de ser implementadas publicamente?

Quando você define uma interface, você não definir o nível de acesso para os membros, uma vez que todos os membros de interface são public. Mesmo se a interface, como tal, é internal, os membros ainda são considerados public. Quando você faz uma aplicação implícita de tal membro de um a assinatura deve corresponder, por isso precisa ser public.

Em relação expondo o getter, gostaria de sugerir fazer um explícita implementação da interface em vez disso, e criando uma propriedade internal para expor o valor:

internal IFirstInterface First { get; private set; }

IFirstInterface ISecondInterface.First
{
    get { return this.First; }
}

Answer 3

Eu sei que este post é de alguns anos, mas eu acho que é importante notar que você pode implementar uma interface interna em uma classe pública, veja os links a seguir:

http://forums.create.msdn.com/forums/p/29808/ 167820.aspx
http://msdn.microsoft.com/en-us/ biblioteca / aa664591% 28VS.71% 29.aspx

Um exemplo do primeiro link:

internal interface ISecretInterface
{
    string Property1 { get; }
}

public class PublicClass : ISecretInterface
{
    // class property
    public string Property1
    {
        get { return "Foo"; }
    }

    // interface property
    string ISecretInterface.Property1
    {
        get { return "Secret"; }
    }
}