c# - solución - no se puede crear una instancia de una interfaz

¿Cómo implemento miembros de interfaces internas?

Question

He estado refactorizando el código base del proyecto en el que estoy trabajando actualmente para que las clases / interfaces que no son útiles más allá de los límites del ensamblaje 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 implementados públicamente? Si implementa la interfaz en una clase interna, ¿no deberían ser internos los miembros implementados? Este no es un gran problema ya que los miembros de la interfaz no serán de acceso público de todos modos, dado que la clase es interna. Simplemente parece contra intuitivo.

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

Accesibilidad inconsistente: el tipo de propiedad ''IFirstInterface'' es menos accesible que la propiedad ''Implementer.First''

¿Hay alguna manera 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 mejor las implicaciones del modificador interno.

Answer 1

¿Por qué los miembros de las interfaces internas tienen que ser implementados 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 al captador, sugeriría realizar 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 2

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, vea los siguientes enlaces:

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

Answer 3

Solo para notar: el código que realmente proporcionó se compila, porque Implementer es una clase interna. El problema viene cuando el Implementer es público.

La forma de evitar esto es usar la implementación de la interfaz explícita:

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

No puede tener el setter allí, porque está implementando explícitamente la interfaz que no define al setter. Podrías hacer esto como 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, ya que complica 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.