Problème de cast générique (T)

Bonjour,

J'ai un problème avec une classe que je suis en train de développer, qui comporter une interface avec un type générique.

Tout d'abord voici le code de l'interface :

Code:

---

1 2 3 4 5

public interface ISimpleDaoResultset<T> { void EndFillQueryEvent(List<T> results); }

---

Plus tard je crée une classe qui va l'utiliser :

Code:

---

1 2 3 4 5 6 7 8

public class ACTUALITES_EXTENDED_RESULTSET : ISimpleDaoResultset<ACTUALITES_EXTENDED> { public void EndFillQueryEvent(List<ACTUALITES_EXTENDED> results) {   } }

---

J'ai en parallèle une classe générique qui va me permettre de l'utiliser en récupérant les types etc.
Mais je ne peux pas savoir le type exact à l'intérieur, donc j'ai un truc comme ça :

Citation:

---

List<dynamic> results = new List<dynamic>();

InstanceDe_ACTUALITES_EXTENDED_RESULTSET.EndFillQueryEvent(results);

---

Et là c'est le plantage !

Ca me dit que je donne des arguments incorrects car je passe une List<dynamic> et non une List<ACTUALITES_EXTENDED>

J'ai bien sûr essayé tout de suite ça :

Citation:

---

Type mT = ... //ici récupération du type ACTUALITES_EXTENDED
List<typeof(mT )>

---

Mais ça ne compile pas...

D'ou ma question : ce que je veux faire est-il possible ? et si oui, l'un d'entre vous aurait-il la solution ? ;)

En vous remerciant,

Bonjour.

En supposant que EndFilmQueryEvent doit lire la liste, alors tu dois soit recréer une liste (via List<>.ConvertAll), soit modifier la signature de ta fonction pour qu'elle accepte un IEnumerable<> (pour profiter de la covariance) voire un IReadOnlyList<> à partir du dotnet 4.5. Grosso modo la covariance est permise sur les structures en lecture seule, pas en écriture. Car si toute énumération de chaînes est une énumération d'objets, en revanche une liste de chaînes ne peut pas accepter d'objets. Au passage il n'y a en général que peu de raisons de passer des IList et on préfère les énumérables, plus flexibles et autorisant la covariance.

Si toutefois EndFillQueryEvent doit modifier la liste, alors il faut rendre cette méthode générique.


PS : Attention avec le terme "plantage" pour parler des erreurs de compilation, ça peut nous induire en erreur. ;)

Code:

---

Attention avec le terme "plantage" pour parler des erreurs de compilation

---

Salut DonQuiche, merci pour ta réponse.

Alors j'ai bien fait attention aux termes : dans le 1er cas, il s'agit bien d'un plantage à l'exécution (pb de cast). Alors que dans le 2ème, quand j'essaye de faire le List<typeof(MonObjet)> ça ne compile pas.

Comme tu l'indiques en effet avec un IEnumerable on peut déjà faire plus de chose, notamment convertir un type List<dynamic>.

Je suis donc parti la-dessus. J'ai également récupéré le type "final" qui doit être casté...
Par contre maintenant comment l'utiliser ?

Voici mon code simplifié :

Code:

---

1 2 3 4 5 6 7

Type mTypeResultset = Type.GetType( "ACTUALITES_EXTENDED_RESULTSET" );   Type typeResult = mTypeResultset.GetMethod("EndFillQueryEvent").GetParameters().FirstOrDefault().ParameterType;   IEnumerable<dynamic> results = new IEnumerable<dynamic>();

---

Du coup comment remplacer

Code:

---

1 2	IEnumerable<dynamic> results = new IEnumerable<dynamic>();

---

par un truc comme ça :

Code:

---

IEnumerable<typeResult > results = new IEnumerable<typeResult >();

---

je suis finalement un peu dans le même problème....

J'ai un peu de mal à saisir ce que tu veux faire et j'ai l'impression, peut-être fausse, que tu t'es embarqué dans un machin bancal qui te conduit dans une impasse.

Concernant ta question, pour construire des génériques à la volée il faut faire :

Code:

---

Type listOfInt = typeof(List<>).MakeGenericType(typeof(int));

---

Sauf que ça ne t'avance pas à grand chose et que c'est bien compliqué (et on peut exploiter dynamic pour faire automatiquement toute cette plomberie). Encore une fois je pense que le problème est en amont et que tu dois faire machine arrière. Quelques questions pour m'aider à comprendre :
* Tu dis avoir utilisé des énumérables mais si ta méthode accepte désormais un IEnumerable<ACTUALITES_EXTENDED_RESULTSET> tu peux lui fournir ton IEnumerable<dynamic> donc où est le problème restant ?
* Reçois-tu des "dynamic" ou est-ce toi qui les a introduits pour résoudre ton problème ? Sinon quel était le type le plus précis dont tu disposais ?
* EndFillQueryEvent modifie t-elle la liste reçue en argument où la lit-elle ?


Enfin je reviens un peu aux bases : pour passer un List<T1> à une méthode acceptant un List<T2>, soit on n'a pas vraiment besoin d'une liste et on met simplement des énumérables aux deux endroits, soit on a vraiment besoin d'une liste et alors il faut soit convertir/reconvertir soit rendre la méthode générique. Dans tous les cas tu ne feras pas passer un canard (List<T1>) pour un chevreuil (List<T2>) quelles que soient les bidouilles que tu utiliseras (réflexion ou dynamiques).

Ouais,
J'essaye de comprendre là et en effet je me suis avancé un peu vite :

En fait pour obtenir mon IEnumerable j'ai fait ça :

Code:

---

1 2 3

List<dynamic> results = new List<dynamic>(); resultset.EndFillQueryEvent(results.AsEnumerable());

---

Ca compile mais ça plante avec la même erreur à l'execution.

En fait le but c'est d'utiliser le résultat EndFillQueryEvent.
Dans ma classe qui implémente ISimpleDaoResultset j'ai donc :

Code:

---

1 2 3 4 5

public void EndFillQueryEvent(IEnumerable<ACTUALITES_EXTENDED> results) {   }

---

Et j'aimerais exploités ces résultats... Avec ce que je veux faire ils seraient donc castés automatiquement.

Si je peux, j'aimerais de faire ça par exemple:

Code:

---

1 2 3 4 5

public void EndFillQueryEvent(IEnumerable<dynamic> results) { var d = ((IEnumerable<ACTUALITES_EXTENDED>)results).ToList(); }

---

Citation:

---

Envoyé par stailer

Ca compile mais ça plante avec la même erreur à l'execution.

---

En fait tel quel ça ne compile même pas, du moins pas avec un EndFillQueryEvent acceptant une énumération de ACTUALITES_EXTENDED.


Ce que je peux te proposer c'est de caster tes dynamiques en ACTUALITES_EXTENDED :

Code:

---

1 2 3 4 5 6

EndFillQueryEvent(results.Cast<ACTUALITES_EXTENDED>());   public void EndFillQueryEvent(IEnumerable<ACTUALITES_EXTENDED> results) { var d = results.ToList(); }

---

Code:

---

1 2 3 4 5 6

EndFillQueryEvent(results);   public void EndFillQueryEvent(IEnumerable<dynamic> results) { var d = results.Cast<ACTUALITES_EXTENDED>().ToList(); }

---

Je préfère la première solution, qui me semble plus propre puisque EndFillQueryEvent ne peut fonctionner qu'avec des ACTUALITES_EXTENDED, donc autant le faire apparaître dans la signature. Note que si ça lève une exception c'est qu'un de tes éléments n'est pas du type ACTUALITES_EXTENDED et ceci ne peut pas être contourné, à moins de le garder sous forme de "dynamic" et de ne jamais tenter de le caster en ACTUALITES_EXTENDED.



Enfin attention avec dynamic, son usage est rarement justifié. Si tu l'as utilisé pour contourner une autre difficulté je t'invite là aussi à revenir en amont pour revenir sur cette décision.

Nos esprits se rejoignent :

Concrètement, sans rentrer dans les détails, en passant avec du yield (car je ne peux faire un new INumerable<dynamic>) , j'arrive à faire fonctionner mon code avec ta 1ère solution (j'ai exactement le même code que toi).

Mais le top serait évidemment de proposer la 2ème solutions. Et c'est là que ça coince :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public void EndFillQuery(IEnumerable<dynamic> resultDatas) { if (resultDatas.Count() > 0) { Type mTypeResultset = Type.GetType(this._query.Model + "_RESULTSET, " + this._query.Namespace); if (mTypeResultset != null) { if (mTypeResultset.GetInterface("ISimpleDaoResultset`1") == null) throw new Exception("Votre classe de résultats doit implémenter ISimpleDaoResultset<T>");   dynamic resultset = Activator.CreateInstance(mTypeResultset); resultset.EndFillQueryEvent(resultDatas); } } }

---

Cette méthode est dans ma classe générique qui appelle la méthode "EndFillQueryEvent".

je ne peux donc pas connaitre son type à l'avance...

Avec la 1ère solution je passe un IEnumerable<dynamic> à EndFillQueryEvent(IEnumerable<dynamic> resultats) C'est bon ça marche.

Dans la 2ème solution, ça ne marche pas car je passe un IEnumerable<dynamic> à EndFillQueryEvent(IEnumerable<ACTUALITES_EXTENDED> resultats)

Bien que ce soit un IEnumerable, C# ne fait pas le conversion automatiquement.

Je crois que je suis coincé...

Ok, je comprends maintenant où était ton problème. Bon on pourrait toujours suivre ce que tu as fait et obtenir manuellement la méthode génériquue Enumerable.Cast<>, créer manuellement un construct avec MethodInfo.MakeGenericMethod etc. Sauf que, disons-le, c'est lourd et peu lisible. Deux solutions propres s'offrent à toi:

a) Ajouter une interface non-générique ISimpleDaoResultset à ISimpleDaoResultset<T>. Ces interfaces non-génériques permettent de manipuler l'objet lorsque le type est inconnu.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

interface ISimpleDaoResultset { EndFillQueryEvent(IEnumerable results); }   interface ISimpleDaoResultset<T> : ISimpleDaoResultset { EndFillQueryEvent(IEnumerable<T> results); }   class ACTUALITES_EXTENDED_RESULTSET : ISimpleDaoResultset<ACTUALITES_EXTENDED> { public void EndFillQueryEvent(IEnumerable results) { EndFillQueryEvent(results.Cast<ACTUALITES_EXTENDED>()) }   public void EndFillQueryEvent(IEnumerable<ACTUALITES_EXTENDED> results) { } }

---

b) Mais en général, si le type est inconnu c'est seulement au moment de la construction. Si tel est le cas allons plus loin et confions à une factory spécialisée le soin de faire toute la construction. Et hop : adieu Activator.CreateInstance, Reflection et compagnie.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

interface IFactory { Object CreateInstance(IEnumerable results); }   class ACTUALITES_EXTENDED_Factory : IFactory { public Object CreateInstance(IEnumerable results) { var instance = new ACTUALITES_EXTENDED_RESULTSET(); instance.EndFillQueryEvent(results.Cast<ACTUALITES_EXTENDED>()); return instance; } }   class ??? { void EndFillQuery(IEnumerable<dynamic> resultDatas) { if (resultDatas.Count() > 0) { this._query.Factory.CreateInstance(resultDatas); // OU: GetFactory(_query.Model).CreateInstance(resultDatas); } } }

---

Note enfin que si tu n'as en fait pas besoin de créer d'objet, dans ce cas un motif de conception "wrapper" est mieux adapté que la factory (et assez proche ici).



PS : comme tu le voix les interfaces non-génériques remplacent avantageusement les énumérations de dynamiques. Et l'intérêt est qu'une interface générique peut implémenter un alter-égo non-générique, c'est ce que font toutes les structures de données du framework (List<> et compagnie).

Citation:

---

Bien que ce soit un IEnumerable, C# ne fait pas le conversion automatiquement.

---

Elle n'est automatique que dans un sens, du plus spécialisé vers le moins spécialisé, de TEnfant vers TParent. Dans ce sens-ci c'est de la covariance et dans le sens inverse c'est de la contravariance. Grosso modo (je simplifie), les structures en lecture seule sont covariantes tandis que les délégués sont contravariants et covariants.

Superbe.

Je te remercie beaucoup pour ton aide, ton code est hyper intéressant (surtout la partie CreateInstanc).

Je marque le sujet comme résolu et je vais essayer d'implémenter tout ça.

Mais déjà j'en ai appris un peu plus sur la Covariance et la Contravariance.

Merci merci :ccool:

Heureux d'avoir pu t'aider, les génériques peuvent rapidement nous faire tourner en bourrique. ;)