Aufruf von InsertBulk <T> (IEnumerable <T> pocos) aber nur zur Laufzeit bekannt

Question

NPoco (ein .NET-Mikro-ORM, abgeleitet von PetaPoco) verfügt über eine Methode zum Masseneinfügen von Datensätzen in eine Datenbank mit einer Liste eines generischen Typs . Die Methodensignatur ist:

void InsertBulk<T>(IEnumerable<T> pocos); 

Intern nimmt es den Namen des Typs T und verwendet es die DB-Tabelle, um zu bestimmen einzufügen in (in ähnlicher Weise die Eigenschaftsnamen des Typs sind mit den Spaltennamen abgebildet). Daher ist es von entscheidender Bedeutung, dass eine Variable vom richtigen Typ an die Methode übergeben wird.

Meine Herausforderung ist dies:

• ich gegeben wird eine Liste der Objekte in die DB einzufügen, wie List<IDataItem> wo IDataItem ist eine Schnittstelle, die alle einsetzbaren Objekte Klassen
• Die Liste implementieren muss, kann enthalten Objekte jeglicher Art, die IDataItem, und es kann eine Mischung von Typen in der Liste
• um das Problem zu unterstreichen implementiert - ich weiß nicht, zum Zeitpunkt der Kompilierung des tatsächlichen konkreten Typen, ich muß passieren zu InsertBulk

Ich habe den folgenden Ansatz versucht, aber das Ergebnis von Convert.ChangeType ist Objekt, also übergebe ich eine Liste von Objekten an InsertBulk, die ungültig ist.

private static Exception SaveDataItemsToDatabase(List<IDataItem> dtos) 
    { 
     using (var db = new DbConnection()) 
     { 
      try 
      { 
       var dtosByType = dtos.GroupBy(x => x.GetType()); 

       db.Data.BeginTransaction(); 

       foreach (var dataType in dtosByType) 
       { 
        var type = dataType.Key; 
        var dtosOfType = dataType.Select(x => Convert.ChangeType(x, type)); 

        db.Data.InsertBulk(dtosOfType); 
       } 

       db.Data.CommitTransaction(); 

       return null; 
      } 
      catch (Exception ex) 
      { 
       db.Data.RollbackTransaction(); 

       return ex; 
      } 
     } 
    } 

Gibt es eine Möglichkeit, dies zu erreichen?

Answer 1

Sie müssen eine neue Liste des Typs List<T> erstellen und alle Ihre Artikel dorthin kopieren, dann rufen Sie InsertBulk über Reflexion.

foreach(var g in groups) 
{ 

    var dataItemType = g.Key; 
    var listType = typeof(List<>).MakeGenericType(new [] { dataItemType }); 
    var list = (IList) Activator.CreateInstance(listType); 

    foreach(var data in g) 
     list.Add(data); 

    db.Data.GetType() 
      .GetMethod("InsertBulk") 
      .MakeGenericMethod(dataItemType) 
      .Invoke(db.Data, new object[] { list }); 

} 

Sehen Sie es, hier zu arbeiten: https://dotnetfiddle.net/BS2FLy

Answer 2

Dieser Code könnte Ihnen helfen zu tun, was Sie (wenn auch ein wenig hacky) wollen.

class Program { 
    static void Main() { 
     var items = new IDataItem[] { 
      new TestItem(), 
      new TestItem(), 
      new TestItem2(), 
      new TestItem2(), 
     }; 

     foreach (var kv in items.GroupBy(c => c.GetType())) { 
      // group by actual type 
      var type = kv.Key; 
      var batch = kv.ToArray(); 
      // grab BulkInsert<Type> method 
      var insert = typeof(Test).GetMethod("BulkInsert").MakeGenericMethod(type); 
      // create array of Type[] 
      var casted = Array.CreateInstance(type, batch.Length); 
      Array.Copy(batch, casted, batch.Length); 
      // invoke 
      insert.Invoke(new Test(), new object[] { casted}); 
     }    

     Console.ReadKey(); 
    }   
} 

public interface IDataItem { 

} 

public class TestItem : IDataItem { 

} 

public class TestItem2 : IDataItem 
{ 

} 

public class Test { 
    public void BulkInsert<T>(IEnumerable<T> items) { 
     Console.WriteLine(typeof(T).Name); 
    } 
} 

Wenn Ihr Original-Code verwenden, wird es so etwas wie:

private static Exception SaveDataItemsToDatabase(List<IDataItem> dtos) 
    { 
     using (var db = new DbConnection()) 
     { 
      try 
      {      
       db.Data.BeginTransaction(); 
       foreach (var dataType in dtos.GroupBy(x => x.GetType())) { 
        var type = dataType.Key; 
        var items = dataType.ToArray(); 
        var insert = db.Data.GetType().GetMethod("BulkInsert").MakeGenericMethod(type); 
        // create array of Type[] 
        var casted = Array.CreateInstance(type, items.Length); 
        Array.Copy(items, casted, items.Length); 
        // invoke 
        insert.Invoke(db.Data, new object[] {casted}); 
       } 

       db.Data.CommitTransaction(); 

       return null; 
      } 
      catch (Exception ex) 
      { 
       db.Data.RollbackTransaction(); 

       return ex; 
      } 
     } 
    } 

Answer 3

Sie so etwas wie dies versuchen könnte:

private static Exception SaveDataItemsToDatabase(List<IDataItem> dtos) 
    { 
     using (var db = new DbConnection()) 
     { 
      try 
      { 
       var dtosByType = dtos.GroupBy(x => x.GetType()); 

       db.Data.BeginTransaction(); 
       var method = db.Data.GetType().GetMethod("InsertBulk"); 
       foreach (var dataType in dtosByType) 
       { 
        var genericMethod = method.MakeGenericMethod(dataType.Key); 
        genericMethod.Invoke(db.Data, new object[] { dataType.Value };     
       } 

       db.Data.CommitTransaction(); 

       return null; 
      } 
      catch (Exception ex) 
      { 
       db.Data.RollbackTransaction(); 

       return ex; 
      } 
     } 
    } 

Answer 4

Ich werde auf eine Vermutung nehmen dieses, weil ich nicht den Code habe, um es auf meiner Seite zu führen.

Wie wäre:

private static Exception SaveDataItemsToDatabase(List<IDataItem> dtos) 
{ 
    using (var db = new DbConnection()) 
    { 
     try 
     { 

      db.Data.BeginTransaction(); 

      dtos 
       .GroupBy(dto => dto.GetType()) 
       .ForEach(grp => { 
        db.Data.BulkInsert(dtos.Where(n => n.GetType().Equals(grp.Key).ToList()); 
       }); 

      db.Data.CommitTransaction(); 

      return null; 
     } 
     catch (Exception ex) 
     { 
      db.Data.RollbackTransaction(); 

      return ex; 
     } 
    } 
}