Cómo implemento miembros de interfaces internas

Question

He estado refacturando 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 ser aplicadas públicamente? Si implementa la interfaz en una clase interna, ¿no deberían los miembros implementados ser internos? 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. Parece contra intuitivo.

2. El principal problema es con el escenario anterior ya que no puede tener un captador pública para IFirstInterface ya que es supuestamente un ejemplo de interfaz interna me sale el siguiente error del compilador:

accesibilidad inconsistente : propiedad tipo 'IFirstInterface' es menos accesible que propiedad 'Implementer.First'

es allí e cualquier 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 forma de entender más profundamente las implicaciones del modificador interno.

Answer 1

Solo para tener en cuenta: el código que en realidad proporcionó hace compilar, porque Implementer es una clase interna. El problema surge cuando Implementer es público.

La manera alrededor de esto es el uso de implementación de interfaz explícita:

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

No se puede tener en la incubadora allí, porque va a implementar de manera explícita la interfaz que no define la incubadora. 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 tienen miembros públicos - no complicar las cosas como esta. Sería extraño que una interfaz pública tenga un miembro interno (¿qué sería interno para 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 deben 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 todavía se consideran public. Cuando realiza una implementación implícita de dicho miembro, la firma debe coincidir, por lo que debe ser public.

En cuanto a la exposición del captador, sugeriría hacer una explícita implementación de la interfaz en su lugar, y la creación de una propiedad internal para exponer el valor:

internal IFirstInterface First { get; private set; } 

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

Answer 3

Sé que este post es un par de años, pero creo que vale la pena señalar que se 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"; } 
    } 
}