Usando Dapper per mappare più di 5 tipi

c# dapper sql

Domanda

Attualmente sto costruendo una query SELECT che unisce 12 tabelle insieme. Sto usando Dapper per tutte le mie altre domande e funziona benissimo. Il problema è che i metodi generici hanno solo cinque parametri generici.

Ho precedentemente modificato il codice per supportare fino a 6 per un'altra query, ma ora non penso davvero che dovrei hackerare altri 6 livelli di generici.

C'è un modo per passare dapper una serie di tipi e restituisce i risultati come una matrice di oggetti, che posso lanciare manualmente se devo?

Potrei anche avvicinarmi al problema nel modo sbagliato! Qualsiasi aiuto sarà apprezzato!

Risposta accettata

In un progetto su cui ho lavorato ho visto qualcosa del genere per ottenere più di 7 tipi mappati. Abbiamo usato 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"
);

QueryString è auto-esplicativo. Il parametro splitOn dice come Dapper dovrebbe dividere le colonne dall'istruzione SELECT in modo che tutto possa essere mappato correttamente agli oggetti, puoi leggere qui .


Risposta popolare

È possibile utilizzare una query dinamica e mapparla in seguito. Qualcosa come questo

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....));

Modifica: con un set di risultati piuttosto ampio, un'altra opzione potrebbe essere quella di utilizzare più query e quindi utilizzare un Grid Reader. Potrebbe funzionare per te.

C'è l'esempio tratto dall'età elegante:

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();
   ...
} 


Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché