¿Cómo implemento miembros de interfaces internas?

Question

He estado refactorizando la base de código del proyecto en el que estoy actualmente para que las clases / interfaces que no son útiles más allá de los límites del ensamblado se declaren como internas (en lugar de públicas). Pero me he encontrado con un problema con el siguiente código:

internal interface IFirstInterface
{
    ...
}

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

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

Mis preguntas:

1. ¿Por qué los miembros de las interfaces internas tienen que implementarse públicamente? Si implementa la interfaz en una clase interna, ¿no deberían ser internos los miembros implementados? Esto no es un gran problema ya que los miembros de la interfaz no serán accesibles públicamente de todos modos, dado que la clase es interna. Simplemente parece contrario a la intuición.

2. El principal problema es con el escenario anterior ya que no puedo tener un captador público para IFirstInterface ya que supuestamente es una interfaz interna, es decir, obtengo el siguiente error del compilador:

  

Accesibilidad inconsistente: propiedad   tipo 'IFirstInterface' es menos   accesible que la propiedad   'Implementer.Primero'

¿Hay alguna forma de evitar esto?

Nota : Me doy cuenta de que probablemente haya poco valor en este ejercicio de refactorización, pero pensé que sería una buena manera de entender más profundamente las implicaciones del modificador interno.

Answer 1

Solo para tener en cuenta: el código que ha proporcionado sí se compila , porque Implementer es una clase interna. El problema surge cuando Implementer es público.

La forma de evitar esto es utilizar una implementación de interfaz explícita:

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

No puede tener el configurador allí, porque está implementando explícitamente la interfaz que no define al configurador. Usted podría hacer esto como una alternativa:

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

Es desafortunado que las interfaces internas tengan miembros públicos; complican cosas como esta. Sería extraño que una interfaz pública tenga un miembro interno (¿para qué sería interno: el implementador o el declarante?) Pero para las interfaces internas tiene mucho más sentido.

Answer 2

  

¿Por qué los miembros de las interfaces internas tienen que implementarse públicamente?

Cuando define una interfaz, no define el nivel de acceso para los miembros, ya que todos los miembros de la interfaz son public . Incluso si la interfaz como tal es internal , los miembros aún se consideran public . Cuando realiza una implementación implícita de dicho miembro, la firma debe coincidir, por lo que debe ser public .

Con respecto a exponer el getter, sugeriría hacer una implementación explícita de la interfaz y crear una propiedad internal para exponer el valor:

internal IFirstInterface First { get; private set; }

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

Answer 3

Sé que esta publicación tiene algunos años, pero creo que vale la pena señalar que puede implementar una interfaz interna en una clase pública, consulte los siguientes enlaces:

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

Un ejemplo del primer enlace:

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"; }
    }
}