Comment lancer une interface en tant que type dans C#?

Question

J'ai une propriété qui retourne une interface. Pendant le débogage, je peux casser ce qui a été retourné et tant que c'est l'interface, Visual Studio est assez intelligent pour connaître le type dérivé qu'il est réellement. Je suppose que c'est en utilisant la réflexion ou quelque chose. Je ne suis pas sûr. Ma question est, est-ce que je peux avoir cette même information disponible à moi pendant l'exécution ainsi je peux créer une variable du type approprié et jeter l'interface comme cela? Voici ce que je dis:

IPreDisplay preDisplay = cb.PreDisplay; 

Si preDisplay est un RedPreDisplay je voudrais être capable de coder

RedPreDisplay tmp = preDisplay as RedPreDisplay; 

Ou si preDisplay était un GreenPreDisplay ...

GreenPreDisplay tmp = preDisplay as GreenPreDisplay; 

etc ... Je voudrais éviter une déclaration de commutation désordonnée si possible, et si je pouvais utiliser des génériques, ce serait génial.

Si vous avez des conseils ou des exemples de comment je peux le faire, s'il vous plaît partager.

Answer 1

Selon ce que vous essayez de faire, vous devriez probablement ajouter une méthode/propriété d'action à l'interface, de cette façon vous n'avez pas besoin de connaître le type - qui est le polymorphisme.

par exemple:

IResultLiteEntity preDisplay = cb.PreDisplay; 
preDisplay.Render(); // New Render method on the interface... 

Answer 2

Quand vous frappez une situation où vous avez besoin de faire cela, cela signifie que vous faites quelque chose de mal. Vous devez sauvegarder et comprendre pourquoi votre conception exige que vous le fassiez. Si vous vous trouvez coincé là, je vous recommande fortement de poster une nouvelle question pour obtenir de l'aide pour la conception - il y a beaucoup de gens intelligents ici qui peuvent vous aider.

Pour répondre à votre question directement, non - vous ne pouvez pas le faire sans une sorte de if/else ou conditionnel, car vous devez être explicite avec des types statiques. Vous pouvez utiliser la réflexion pour appeler la méthode, mais puisque vous semblez avoir besoin d'appeler quelque chose que l'interface ne supporte pas - mais certains objets le font - vous devrez quand même coder une condition de type statique pour appeler cette méthode. Il suffit de coder les types directement.

Modifier: par la discussion dans les commentaires, la meilleure solution à ceci est d'ajouter une deuxième interface aux classes qui ont cette autre propriété ou méthode. Ensuite, vous pouvez faire une simple vérification:

IPreDisplay display = cb.PreDisplay; 
IOtherInterface displayAsOther = display as IOtherInterface; 
if(displayAsOther != null) 
{ 
    displayAsOther.OtherMethod(); 
} 

Answer 3

Le but entier d'utiliser des interfaces est que le code d'exécution ne doit pas être au courant du type exact. Essayez d'exposer toutes les informations dont vous pourriez avoir besoin via l'interface elle-même, de sorte que vous n'avez pas besoin de lancer. Naturellement, il se peut que vous ayez encore besoin de lancer une interface vers une implémentation concrète (type spécifique) en de rares occasions. Si vous pouviez fournir un peu plus de contexte, cela pourrait être utile.

Answer 4

@Rex M est absolument correct. Le problème réside avec votre code et la structure sous-jacente. En règle générale, vous ne devriez pas faire ce que vous essayez de faire; code contre l'interface seulement. Cela dit, il y a l'opérateur is qui pourrait vous aider si vous avez hérité de mauvais code et que vous avez besoin de le corriger.Par exemple:

if(myInstance is MyBaseType) 
{ 
    MyBaseType myInstanceAsBaseType = myInstance as MyBaseType; 
    // handle MyBaseType specific issue 
} 
else if(myInstance is MyOtherBaseType) 
{ 
    MyOtherBaseType myInstanceAsOtherBaseType = myInstance as MyOtherBaseType; 
    // handle MyOtherBaseType specific issue. 
} 

Les génériques ne vous aideront pas, et vous ne pourrez pas le faire dans le cadre d'une instruction switch. Mais ça va vous donner quelque chose qui fonctionne, mais qui fonctionne de façon très laide.

Answer 5

Comme d'autres répondants l'ont souligné, vous devriez probablement réfléchir à la raison pour laquelle votre conception requiert une logique différente pour différents types qui ne peuvent pas être retirés dans une interface.

Cependant, en supposant qu'il ya de bonnes raisons pour cela, vous avez seulement quelques options:

1. réflexion utilisation. Il s'agit généralement d'un code lent et sujet aux erreurs, qui est également fragile lorsque votre implémentation change (par exemple, les méthodes sont renommées, etc.).
2. Utilisez un modèle if/else if/else à distribuer en fonction des vérifications d'exécution du type. C'est à peu près votre seul autre choix dans les versions antérieures à la version 4.0 de C#.
3. Si vous utilisez C# 4.0, vous pouvez utiliser l'objet attribuer à un var dynamique et à l'envoi d'exécution à une méthode surchargée dont la signature varie pour chacun des types pris en charge (voir exemple ci-dessous).

Voici un exemple de répartition dynamique C# 4.0:

void Foo() 
{ 
    dynamic preDisplay = cb.PreDisplay; 
    DoSomethingWith(preDisplay); // runtime dispatch using dynamic runtime (DLR) 
} 

void DoSomethingWith(RedPreDisplay r) { ... } // code specific to RefPreDisplay 
void DoSomethingWith(GreenPreDisplay g) { ... } // code specific to GreenPreDisplay 
void DoSomethingWIth(IPreDisplay o) { ... } // catch-all