Generisches QueryMultiple mit Dapper

Question

Ich habe eine Basis-Repository mit einem generischen Methode Get Daten zurück mit Dapper wie

public T Get<T>(Func<IDbConnection, T> query) 
    { 
     using (IDbConnection db = new SqlConnection(ConfigurationManager.ConnectionStrings["myDB"].ConnectionString)) 
     { 
      return query.Invoke(db); 
     } 
    } 

aber jetzt habe ich die Notwendigkeit, mehrere Daten zurückzukehren. Die DAL-Abfrage ist wie folgt:

var multi = db.QueryMultiple(getCarDataSp , new { CustomerID = customerId, Year = year }, 
           commandType: CommandType.StoredProcedure)); 

var cars = multi.Read<CarDTO>(); 
var options = multi.Read<CarOptionDTO>(); 

//wire the options to the cars 
foreach(var car in cars){ 
    var carOptions = options.Where(w=>w.Car.CarID == car.CarID);  //I would override Equals in general so you can write w.Car.Equals(car)...do this on a common DataModel class 
    car.Options = carOptions.ToList(); 
} 

es möglich wäre, eine generische GetMultiple in meinem BaseRepository zu haben oder es eine Frage der Einwickeln des bekommen mehr in meiner Get-Methode und dann Autos und Optionen dort eigenen getrennt sein Anrufe bekommen?

Answer 1

Sie könnten so etwas tun, das ein Tupel zurückgibt, das IEnumerables von jedem Typ enthält, nach dem Sie suchen.

Im Basis Repository

(es ist im Grunde ein Bündel von Überlastungen ... können Sie mehr Überlastungen hinzufügen, wenn Sie mehr Arten haben).

public Tuple<IEnumerable<T1>, IEnumerable<T2>> GetMultiple<T1, T2>(string sql, object parameters, 
             Func<GridReader, IEnumerable<T1>> func1, 
             Func<GridReader, IEnumerable<T2>> func2) 
     { 
      var objs = getMultiple(sql, parameters, func1, func2); 
      return Tuple.Create(objs[0] as IEnumerable<T1>, objs[1] as IEnumerable<T2>); 
     } 

     public Tuple<IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>> GetMultiple<T1, T2, T3>(string sql, object parameters, 
             Func<GridReader, IEnumerable<T1>> func1, 
             Func<GridReader, IEnumerable<T2>> func2, 
             Func<GridReader, IEnumerable<T3>> func3) 
     { 
      var objs = getMultiple(sql, parameters, func1, func2, func3); 
      return Tuple.Create(objs[0] as IEnumerable<T1>, objs[1] as IEnumerable<T2>, objs[2] as IEnumerable<T3>); 
     } 

     private List<object> getMultiple(string sql, object parameters,params Func<GridReader,object>[] readerFuncs) 
     { 
      var returnResults = new List<object>(); 
      using (IDbConnection db = new SqlConnection(ConfigurationManager.ConnectionStrings["myDB"].ConnectionString)) 
      { 
       var gridReader = db.QueryMultiple(sql, parameters); 

       foreach(var readerFunc in readerFuncs) 
       { 
        var obj = readerFunc(gridReader); 
        returnResults.Add(obj); 
       } 
      } 

      return returnResults; 
     } 

In Abgeleitet Repository

(ziemlich sauber und was noch wichtiger ist, getippt!)

public class Foo { } 

     public class Bar { } 

     public void sample() 
     { 
      var sql = "select * from Foo; select * from Bar"; 
      var foosAndBars = this.GetMultiple(sql, new { param = "baz" }, gr => gr.Read<Foo>(), gr => gr.Read<Bar>()); 
      var foos = foosAndBars.Item1; 
      var bars = foosAndBars.Item2; 
     }