Utiliser Dapper pour mapper plus de 5 types

c# dapper sql

Question

Je construis actuellement une requête SELECT qui joint 12 tables ensemble. J'ai utilisé Dapper pour toutes mes autres requêtes et cela fonctionne très bien. Le problème est que les méthodes génériques ne comportent que cinq paramètres génériques.

J'ai déjà modifié le code pour prendre en charge jusqu'à 6 pour une autre requête, mais maintenant je ne pense vraiment pas que je devrais pirater 6 autres niveaux de génériques.

Y a-t-il un moyen de passer dapper un tableau de types, et il renvoie les résultats sous la forme d'un tableau d'objets, que je peux reproduire manuellement si je le dois?

Je peux aussi aborder le problème dans le mauvais sens! Toute aide serait appréciée!

Réponse acceptée

Dans un projet sur lequel j'ai travaillé, j'ai vu quelque chose comme ça pour obtenir plus de 7 types de cartes. Nous avons utilisé Dapper 1.38:

connection.Query<TypeOfYourResult>
(
   queryString,
   new[]
   {
      typeof(TypeOfArgument1),
      typeof(TypeOfArgument2),
      ...,
      typeof(TypeOfArgumentN)
   },
   objects =>
   {
      TypeOfArgument1 arg1 = objects[0] as TypeOfArgument1;
      TypeOfArgument2 arg2 = objects[1] as TypeOfArgument2;
      ...
      TypeOfArgumentN argN = objects[N] as TypeOfArgumentN;

     // do your processing here, e.g. arg1.SomeField = arg2, etc.
     // also initialize your result

     var result = new TypeOfYourResult(...)

     return result;
   },
   parameters,
   splitOn: "arg1_ID,arg2_ID, ... ,argN_ID"
);

Le queryString est explicite. Le paramètre splitOn indique comment Dapper doit séparer les colonnes de l'instruction SELECT afin que tout puisse être correctement mappé aux objets, vous pouvez le lire ici .


Réponse populaire

Vous pouvez utiliser une requête dynamique et la mapper ultérieurement. Quelque chose comme ça

var result = conn.Query<dynamic>(query).Select(x => new Tuple<Type1, Type2, Type3, Type4, Type5>( 
// type initialization here 
    new Type1(x.Property1,x.Property2),
    new Type2(x.Property3,x.Property4),
    new Type3(x.Property5,x.Property6) etc....));

Modifier: avec un ensemble de résultats plutôt important, une autre option pourrait consister à utiliser plusieurs requêtes, puis à utiliser un lecteur de grille. Cela pourrait fonctionner pour vous.

Il y a l'exemple tiré de l'ère de la taille:

var sql = 
@"
select * from Customers where CustomerId = @id
select * from Orders where CustomerId = @id
select * from Returns where CustomerId = @id";

using (var multi = connection.QueryMultiple(sql, new {id=selectedId}))
{
   var customer = multi.Read<Customer>().Single();
   var orders = multi.Read<Order>().ToList();
   var returns = multi.Read<Return>().ToList();
   ...
} 



Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi