Comment puis-je mettre en œuvre les membres des interfaces internes

J'ai été refactoring de la base de code du projet que je suis actuellement sur, de sorte que les classes/interfaces qui ne sont pas utiles au-delà de l'enceinte de l'assemblée doit être déclarée en tant qu'interne (plutôt que dans le public). Mais j'ai couru dans un problème avec le code suivant:

internal interface IFirstInterface
{
    ...
}

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

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

Mes questions:

Pourquoi les membres d'interfaces internes doivent être publiquement mises en œuvre? Si vous implémentez l'interface sur une classe interne, ne devrait pas mises en œuvre, les membres de l'interne? Ce n'est pas un gros problème depuis l'interface de membres ne sera pas accessible au public de toute façon, compte tenu de la classe interne. Il semble contre-intuitif.
Le principal problème est avec le scénario ci-dessus, car je ne peut pas avoir un public getter pour IFirstInterface car il est soi-disant une interface interne c'est à dire j'obtiens l'erreur suivante à partir du compilateur:

Incompatible accessibilité: de la propriété
type 'IFirstInterface" est moins
accessibles de la propriété
'Oeuvre.D'abord"

Est-il un moyen de contourner cela?

Note: je me rends compte qu'il n'y a probablement que peu de valeur dans ce refactoring de l'exercice, mais j'ai pensé que ce serait une bonne façon pour moi de comprendre plus en profondeur les implications de l'intérieur de modificateur.

Si c'est une option, vous pouvez contourner la limitation de l'interface des méthodes de public, en utilisant une classe de base abstraite à la place.

InformationsquelleAutor jpoh | 2009-08-03

c#interface internal

48

Juste à noter le code que vous avez effectivement fourni ne compiler, parce que Implementer est une classe interne. Le problème vient quand Implementer est public.

Le chemin de ronde, c'est d'utiliser explicitement l'implémentation de l'interface:
```
public class Implementer : ISecondInferface
{
    private IFirstInterface first;
    IFirstInterface ISecondInterface.First { get { return first; } }
}
```
Vous ne pouvez pas avoir le setter là, parce que vous êtes explicitement la mise en œuvre de l'interface qui n'a pas de définir le setter. Vous pourrait ce faire, comme une alternative:
```
public class Implementer : ISecondInterface
{
    internal IFirstInterface First { get; private set; }
    IFirstInterface ISecondInterface.First { get { return First; } }
}
```
Il est malheureux que les interfaces internes ont des membres -, il complique les choses comme cela. Il serait étrange qu'une interface publique d'avoir un membre interne (de ce qui pourrait-il être interne à l'opérateur ou le preneur?) mais pour les interfaces internes qu'il fait beaucoup plus de sens.
- Ah, c'est exact. Je vais modifier ma question c'est donc moins la confusion chez les lecteurs. Merci!
InformationsquelleAutor Jon Skeet
11

Pourquoi les membres d'interfaces internes doivent être publiquement mises en œuvre?

Lorsque vous définissez une interface, vous n'avez pas de définir le niveau d'accès pour les membres, car tous les membres d'interface sont public. Même si l'interface en tant que tel est internal, les membres sont toujours considérés comme des public. Lorsque vous faites un implicite de la mise en œuvre d'un tel membre, la signature doit correspondre, donc il doit être public.

Concernant l'exposant de la lecture, je vous suggère de faire un explicite mise en œuvre de l'interface, et la création d'un internal propriété d'exposer la valeur:
```
internal IFirstInterface First { get; private set; }

IFirstInterface ISecondInterface.First
{
    get { return this.First; }
}
```
InformationsquelleAutor Fredrik Mörk
7

Je sais que ce post est un peu vieux, mais je pense qu'il est intéressant de noter que vous pouvez mettre en œuvre une interface interne sur une classe publique, voir les liens suivants:

http://forums.create.msdn.com/forums/p/29808/167820.aspx

http://msdn.microsoft.com/en-us/library/aa664591%28VS.71%29.aspx

Un exemple à partir du premier lien:
```
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"; }
    }
}
```
- Quelle est votre réponse à partir de 2011 différente de la deux réponses à partir de 2009?
- Honnêtement, je ne sais pas et je ne vois pas pourquoi j'aurais ajouté que, bien que je ne n'oubliez pas de le faire. Il n'ajoute rien et j'ai essayé de le comprendre en regardant l'historique de la révision pour voir si il y avait un indice, mais toujours rien. J'étais peut-être avoir un muet jour.
- Pour certaines raisons, cette réponse est plus facile pour moi de consommer que les précédents, car l'explication au début de la réponse des adresses de ma situation et correspond à ce que j'ai Googlé. Merci donc d'indiquer clairement que les classes publiques peuvent mettre en œuvre des interfaces internes et facilement consommable façon ;-).
InformationsquelleAutor Robert

Vous devez vous connecter pour publier un commentaire.