split one big datatable to two separated datatables

I´m exporting datatables to Excel workbook. Problem is that the datatable holds 90000 rows and excel can only hold 67000 rows in every sheet.

So..

How can i divide one big datatable to two dat开发者_StackOverflowatables, maybe with Linq ?

Then i can have datatable1 in sheet1 and datatable2 in sheet2

Sincerly agh

Assuming that you're getting the 90,000 rows for this DataTable from a database somewhere, the most efficient approach would be to modify your SELECT statement into two new SELECT statements, each of which returns < 67,000 rows, and then do everything else the same.

Split your recordset. Perform one SELECT that extracts all 90,000 rows, and split it on Excel import step.

 private List<DataTable> CloneTable(DataTable tableToClone, int countLimit)//Split function
{
    List<DataTable> tables = new List<DataTable>();
    int count = 0;
    DataTable copyTable = null;
    foreach (DataRow dr in tableToClone.Rows)
    {
        if ((count++ % countLimit) == 0)
        {
            copyTable = new DataTable();
            copyTable = tableToClone.Clone();
            copyTable.TableName = "Sample" + count;
            tables.Add(copyTable);
        }
        copyTable.ImportRow(dr);
    }
    return tables;
}


protected void LinkReport_Click(object sender, EventArgs e)
{
    DataTable dt2 = (DataTable)ViewState["dtab"];
    List<DataTable> dt1 = CloneTable(dt2, 5);
    DataSet ds = new DataSet("dst");
    for (int i = 0; i < dt1.Count; i++)
    {
        ds.Tables.Add(dt1[i]);
    }
    string filePath = Server.MapPath("Reports/").ToString() + "master.xls";
    FileInfo file = new FileInfo(filePath);
    if (file.Exists)
    {
        file.Delete();
    }

    Export(ds, filePath);// Export into Excel
}

Clone - The fastest method to create tables with original columns structure is Clone method.

Export into Excel

private void releaseObject(object obj)
{
    try
    {
        System.Runtime.InteropServices.Marshal.ReleaseComObject(obj);
        obj = null;
    }
    catch (Exception ex)
    {
        obj = null;
    }
    finally
    {
        GC.Collect();
    }
}

 public void Export(DataSet ds, string filePath)
{
    string data = null;
    string columnName = null;
    int i = 0;
    int j = 0;
    Excel.Application xlApp;
    Excel.Workbook xlWorkBook;
    //Excel.Worksheet xlWorkSheet;
    Excel.Worksheet xlWorkSheet = null;
    object misValue = System.Reflection.Missing.Value;
    Excel.Range range;

    xlApp = new Excel.ApplicationClass();
    xlWorkBook = xlApp.Workbooks.Add(misValue);
    //xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);


    for (int l = 0; l < ds.Tables.Count; l++)
    {
        xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(l + 1);
        xlWorkSheet.Cells[1, 1] = "Report";
        xlWorkSheet.get_Range("A1:D1", Type.Missing).Merge(Type.Missing);
        xlWorkSheet.get_Range("A1", "D1").Font.Bold = true;
        xlWorkSheet.Cells.Font.Name = "Courier New";

        if (l == 0)
        {
            xlWorkSheet.Name = "Sheet1";
        }
        else if (l == 1)
        {
            xlWorkSheet.Name = "Sheet2";
        }
        else if (l == 2)
        {
            xlWorkSheet.Name = "Sheet3";
        }
        else if (l == 3)
        {
            xlWorkSheet.Name = "Sheet4";
        }
        else if (l == 4)
        {
            xlWorkSheet.Name = "Sheet5";
        }

        for (i = 0; i <= ds.Tables[l].Rows.Count - 1; i++)
        {


            for (j = 0; j <= ds.Tables[l].Columns.Count - 1; j++)
            {
                columnName = ds.Tables[l].Columns[j].ColumnName.ToString();
                xlWorkSheet.Cells[3, j + 1] = columnName;
                data = ds.Tables[l].Rows[i].ItemArray[j].ToString();
                xlWorkSheet.Cells[i + 5, j + 1] = data;
            }
        }
    }


    //for (i = 0; i <= ds.Tables[0].Rows.Count - 1; i++)
    //{
    //    for (j = 0; j <= ds.Tables[0].Columns.Count - 1; j++)
    //    {
    //        data = ds.Tables[0].Rows[i].ItemArray[j].ToString();
    //        xlWorkSheet1.Cells[i + 1, j + 1] = data;
    //    }
    //}          


    xlWorkBook.SaveAs(filePath, Excel.XlFileFormat.xlWorkbookNormal, misValue, misValue, misValue, misValue, Excel.XlSaveAsAccessMode.xlExclusive, misValue, misValue, misValue, misValue, misValue);
    xlWorkBook.Close(true, misValue, misValue);
    xlApp.Quit();

    // kill all excel processes
    Process[] pros = Process.GetProcesses();
    for (int p = 0; p < pros.Length; p++)
    {
        if (pros[p].ProcessName.ToLower().Contains("excel"))
        {
            pros[p].Kill();
            break;
        }
    }

    releaseObject(xlWorkSheet);
    releaseObject(xlWorkBook);
    releaseObject(xlApp);
}

Try this One.. I have Worked out in Visual Studio 2005

DataTable[] splittedtables = dt.AsEnumerable() .Select((row, index) => new { row, index }) .GroupBy(x => x.index / Input From User) // integer division, the fractional part is truncated .Select(g => g.Select(x => x.row).CopyToDataTable()) .ToArray();

This should work.