通過將Linq結果添加到數據表或數據集中來重複使用Linq結果

Question

strong text感謝Tim向我提供了以下代碼：Join/merge two excel files in asp.net and display them in gridview。

我在這篇新文章中的問題是： 如何重新使用或添加linq結果到數據集或數據庫，以便我可以查詢新表而不是兩個單獨的表？ join關鍵字給了我加入這兩個表的可能性。現在我想用這個連接表來運行其他查詢。

我希望我的問題有道理。如果您需要更多信息，請告訴我。

DataSet ds = new DataSet("Stock"); 
using (var dbConnection = new OleDbConnection(connString)) 
using (var dbCommand = new OleDbCommand("SELECT * FROM [Sheet1$]", dbConnection)) 
using (var da = new OleDbDataAdapter(dbCommand)) 
{ 
    da.Fill(ds, "HWTypes"); 
} 

using (var dbConnection = new OleDbConnection(stockConn)) 
using (var dbCommand = new OleDbCommand("SELECT * FROM [Stock_voorlopig$]", dbConnection)) 
using (var da = new OleDbDataAdapter(dbCommand)) 
{ 
    da.Fill(ds, "Stock"); 
} 

var joined = from rType in ds.Tables["HWTypes"].AsEnumerable() 
      join rStock in ds.Tables["Stock"].AsEnumerable() 
      on rType.Field<string>("ProductID") equals rStock.Field<string>("Partno") 
      select new 
      { 
       ProductID = rType.Field<string>("ProductID") 
       // add the other columns you need here 
      }; 


GridView1.DataSource = joined; 
GridView1.DataBind(); 

編輯1：

我試圖做這樣的事情：

private static DataTable JoinDataTablesWithLinq() 
{ 

//rest of the code from above 
return joined.CopyToDataTable(); 
} 

但我收到此錯誤：

The type 'AnonymousType#1' cannot be used as type parameter 'T' in the generic type or method 'System.Data.DataTableExtensions.CopyToDataTable<T>(System.Collections.Generic.IEnumerable<T>)'. There is no implicit reference conversion from 'AnonymousType#1' to 'System.Data.DataRow'. 

任何幫助嗎？

Answer 1

I am trying to do something like this:

private static DataTable JoinDataTablesWithLinq() 
{ 

//rest of the code from above 
return joined.CopyToDataTable(); 
} 

不能創建 「即時」 一DataTable。您選擇了一個不是IEnumerable<DataRow>的匿名類型，您需要使用CopyToDataTable。因此，您必須使用自定義類並填充List<MyClass>以包含您需要的所有屬性，或者必須創建一個DataTable以及所有必需的DataColumns匿名類型並填充它。

你發現並不那麼容易。儘管有一個動態的方法。但是這需要反思，因此它效率不高。

在這裏，我們去...（的my other answer提取物）

你可以建立自己的CopyToDataTable這需要任何的IEnumerable（不僅DataRow），並返回一個新DataTable：

這裏是實施（與MSDN幫助）：

public class ObjectShredder<T> { 
    private System.Reflection.FieldInfo[] _fi; 
    private System.Reflection.PropertyInfo[] _pi; 
    private System.Collections.Generic.Dictionary<string, int> _ordinalMap; 
    private System.Type _type; 

    // ObjectShredder constructor. 
    public ObjectShredder() { 
     _type = typeof(T); 
     _fi = _type.GetFields(); 
     _pi = _type.GetProperties(); 
     _ordinalMap = new Dictionary<string, int>(); 
    } 

    /// <summary> 
    /// Loads a DataTable from a sequence of objects. 
    /// </summary> 
    /// <param name="source">The sequence of objects to load into the DataTable.</param> 
    /// <param name="table">The input table. The schema of the table must match that 
    /// the type T. If the table is null, a new table is created with a schema 
    /// created from the public properties and fields of the type T.</param> 
    /// <param name="options">Specifies how values from the source sequence will be applied to 
    /// existing rows in the table.</param> 
    /// <returns>A DataTable created from the source sequence.</returns> 
    public DataTable Shred(IEnumerable<T> source, DataTable table, LoadOption? options) { 
     // Load the table from the scalar sequence if T is a primitive type. 
     if (typeof(T).IsPrimitive) { 
      return ShredPrimitive(source, table, options); 
     } 

     // Create a new table if the input table is null. 
     if (table == null) { 
      table = new DataTable(typeof(T).Name); 
     } 

     // Initialize the ordinal map and extend the table schema based on type T. 
     table = ExtendTable(table, typeof(T)); 

     // Enumerate the source sequence and load the object values into rows. 
     table.BeginLoadData(); 
     using (IEnumerator<T> e = source.GetEnumerator()) { 
      while (e.MoveNext()) { 
       if (options != null) { 
        table.LoadDataRow(ShredObject(table, e.Current), (LoadOption)options); 
       } else { 
        table.LoadDataRow(ShredObject(table, e.Current), true); 
       } 
      } 
     } 
     table.EndLoadData(); 

     // Return the table. 
     return table; 
    } 

    public DataTable ShredPrimitive(IEnumerable<T> source, DataTable table, LoadOption? options) { 
     // Create a new table if the input table is null. 
     if (table == null) { 
      table = new DataTable(typeof(T).Name); 
     } 

     if (!table.Columns.Contains("Value")) { 
      table.Columns.Add("Value", typeof(T)); 
     } 

     // Enumerate the source sequence and load the scalar values into rows. 
     table.BeginLoadData(); 
     using (IEnumerator<T> e = source.GetEnumerator()) { 
      Object[] values = new object[table.Columns.Count]; 
      while (e.MoveNext()) { 
       values[table.Columns["Value"].Ordinal] = e.Current; 

       if (options != null) { 
        table.LoadDataRow(values, (LoadOption)options); 
       } else { 
        table.LoadDataRow(values, true); 
       } 
      } 
     } 
     table.EndLoadData(); 

     // Return the table. 
     return table; 
    } 

    public object[] ShredObject(DataTable table, T instance) { 

     FieldInfo[] fi = _fi; 
     PropertyInfo[] pi = _pi; 

     if (instance.GetType() != typeof(T)) { 
      // If the instance is derived from T, extend the table schema 
      // and get the properties and fields. 
      ExtendTable(table, instance.GetType()); 
      fi = instance.GetType().GetFields(); 
      pi = instance.GetType().GetProperties(); 
     } 

     // Add the property and field values of the instance to an array. 
     Object[] values = new object[table.Columns.Count]; 
     foreach (FieldInfo f in fi) { 
      values[_ordinalMap[f.Name]] = f.GetValue(instance); 
     } 

     foreach (PropertyInfo p in pi) { 
      values[_ordinalMap[p.Name]] = p.GetValue(instance, null); 
     } 

     // Return the property and field values of the instance. 
     return values; 
    } 

    public DataTable ExtendTable(DataTable table, Type type) { 
     // Extend the table schema if the input table was null or if the value 
     // in the sequence is derived from type T.    
     foreach (FieldInfo f in type.GetFields()) { 
      if (!_ordinalMap.ContainsKey(f.Name)) { 
       // Add the field as a column in the table if it doesn't exist 
       // already. 
       DataColumn dc = table.Columns.Contains(f.Name) ? table.Columns[f.Name] 
        : table.Columns.Add(f.Name, f.FieldType); 

       // Add the field to the ordinal map. 
       _ordinalMap.Add(f.Name, dc.Ordinal); 
      } 
     } 
     foreach (PropertyInfo p in type.GetProperties()) { 
      if (!_ordinalMap.ContainsKey(p.Name)) { 
       // Add the property as a column in the table if it doesn't exist 
       // already. 
       DataColumn dc = table.Columns.Contains(p.Name) ? table.Columns[p.Name] 
        : table.Columns.Add(p.Name, p.PropertyType); 

       // Add the property to the ordinal map. 
       _ordinalMap.Add(p.Name, dc.Ordinal); 
      } 
     } 

     // Return the table. 
     return table; 
    } 
} 

現在你可以添加這些擴展：

public static class CustomLINQtoDataSetMethods { 
    public static DataTable CopyToDataTable<T>(this IEnumerable<T> source) { 
     return new ObjectShredder<T>().Shred(source, null, null); 
    } 

    public static DataTable CopyToDataTable<T>(this IEnumerable<T> source, 
               DataTable table, LoadOption? options) { 
     return new ObjectShredder<T>().Shred(source, table, options); 
    } 
} 

Voilà！現在CopyToDataTable適用於任何類型的IEnumerable<T> :)