Comment lancer une interface vers sa sous-interface?

Question

imaginez que vous avez les interfaces suivantes:

public interface IInterfaceA : IInterfaceX 
{ 
    // 
    // declarations 
    // 
} 

public interface IInterfaceB : IInterfaceX 
{ 
    // 
    // declarations 
    // 
} 

public interface IInterfaceC : IInterfaceX 
{ 
    // 
    // declarations 
    // 
} 

Maintenant, je veux remplacer les trois méthodes suivantes qui effectuent à peu près la même chose avec une seule fonction:

class SomeClass 
{ 
    IInterfaceA myVarA; 
    IInterfaceB myVarB; 
    IInterfaceC myVarC; 

    void SomeMethodA(IInterfaceX someVarX) 
    { 
     myVarA = (IInterfaceA)someVarX; 
    } 

    void SomeMethodB(IInterfaceX someVarX) 
    { 
     myVarB = (IInterfaceB)someVarX; 
    } 

    void SomeMethodC(IInterfaceX someVarX) 
    { 
     myVarC = (IInterfaceC)someVarX; 
    } 
} 

Je pensais à quelque chose comme:

void SomeMethod(IInterfaceX targetVar, IInterfaceX someVarX) 
{ 
    // 
    // here's my problem 
    // 
    targetVar = (CastIDontKnowHowToPerform)someVarX; 
} 

qui est utilisé sth. comme

SomeMethod(myVarA, someVarX);   
SomeMethod(myVarB, someVarX);   
SomeMethod(myVarC, someVarX);   

Mes questions sont les suivantes:

• Est-il possible que je veux?

• Comment effectuer cette conversion Je ne sais pas comment effectuer?

• Peut-être un modèle de conception est plus approprié

Je suis à la recherche de la meilleure façon de factoriser ces trois fonctions en les remplaçant par un seul.

choses que j'ai essayé jusqu'à présent: je utilisé des choses comme object.GetType() et object.GetType() GetInterfaces() qui fonctionne bien pour obtenir le type d'un objet ou son interface (s). mais aucun à définir le type d'un objet à son interface.

espérons que vous pouvez me aider ...

Cordialement,

Inno

[EDIT] Ah, bon sang ... après avoir cliqué sur "Posez vos questions" et ayant une Bref, cela semble être un cas typique pour une fonction générique (ou un modèle en C++ - terme). [/ EDIT]

Answer 1

void SomeMethod<T>(out T targetVar, IInterfaceX someVarX) where T: IInterfaceX 
{ 
     targetVar = (T) someVarX; 
} 

Answer 2

Une possibilité est l'opérateur "is":

void SomeMethod(IInterfaceX someVarX) 
{ 
    if (someVarX is IInterfaceA) 
     SomeMethodA((IInterfaceA)someVarX); 
    else if (... 
} 

Une meilleure méthode serait de mettre l'opération dans le IInterfaceX pour éviter la coulée tout à fait:

void SomeMethod(IInterfaceX someVarX) 
{ 
    someVarX.SomeMethod(); 
}