Bagaimana cara membuat file Excel (.XLS dan .XLSX) dalam C # tanpa menginstal Microsoft Office?

Bagaimana saya bisa membuat lembar bentang Excel dengan C # tanpa memerlukan Excel untuk diinstal pada mesin yang menjalankan kode?

Anda dapat menggunakan perpustakaan yang disebut ExcelLibrary. Ini adalah perpustakaan sumber terbuka gratis yang diposting di Google Code:

Perpustakaan Excel

Ini terlihat sebagai port dari PHP ExcelWriter yang Anda sebutkan di atas. Itu belum akan menulis ke format .xlsx baru, tetapi mereka sedang berusaha menambahkan fungsionalitas itu di.

Ini sangat sederhana, kecil dan mudah digunakan. Plus itu memiliki DataSetHelper yang memungkinkan Anda menggunakan DataSets dan DataTables untuk dengan mudah bekerja dengan data Excel.

ExcelLibrary tampaknya masih hanya berfungsi untuk format Excel yang lebih lama (file .xls), tetapi mungkin menambahkan dukungan di masa depan untuk format 2007/2010 yang lebih baru.

Anda juga dapat menggunakan EPPlus , yang hanya berfungsi untuk file format Excel 2007/2010 (file .xlsx). Ada juga NPOI yang berfungsi dengan baik.

Ada beberapa bug yang diketahui dengan masing-masing perpustakaan seperti yang tercantum dalam komentar. Secara keseluruhan, EPPlus tampaknya menjadi pilihan terbaik seiring berjalannya waktu. Tampaknya lebih aktif diperbarui dan didokumentasikan juga.

Selain itu, seperti yang dicatat oleh @ АртёмЦарионов di bawah, EPPlus memiliki dukungan untuk Pivot Tables dan ExcelLibrary mungkin memiliki beberapa dukungan ( masalah tabel Pivot di ExcelLibrary )

Berikut adalah beberapa tautan untuk referensi cepat:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Lisensi Apache

Berikut beberapa contoh kode untuk ExcelLibrary:

Berikut adalah contoh mengambil data dari database dan membuat buku kerja dari itu. Perhatikan bahwa kode ExcelLibrary adalah baris tunggal di bagian bawah:

//Create the data set and table
DataSet ds = new DataSet("New_DataSet");
DataTable dt = new DataTable("New_DataTable");

//Set the locale for each
ds.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;
dt.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;

//Open a DB connection (in this example with OleDB)
OleDbConnection con = new OleDbConnection(dbConnectionString);
con.Open();

//Create a query and fill the data table with the data from the DB
string sql = "SELECT Whatever FROM MyDBTable;";
OleDbCommand cmd = new OleDbCommand(sql, con);
OleDbDataAdapter adptr = new OleDbDataAdapter();

adptr.SelectCommand = cmd;
adptr.Fill(dt);
con.Close();

//Add the table to the data set
ds.Tables.Add(dt);

//Here's the easy part. Create the Excel worksheet from the data set
ExcelLibrary.DataSetHelper.CreateWorkbook("MyExcelFile.xls", ds);

Membuat file Excel semudah itu. Anda juga dapat secara manual membuat file Excel, tetapi fungsionalitas di atas sangat mengesankan saya.

Jika Anda puas dengan format xlsx, coba proyek GitHub saya, EPPlus . Itu dimulai dengan sumber dari ExcelPackage, tetapi hari ini adalah penulisan ulang total. Ini mendukung rentang, penataan sel, bagan, bentuk, gambar, rentang bernama, AutoFilter dan banyak hal lainnya.

Dan bagaimana dengan menggunakan Open XML SDK 2.0 untuk Microsoft Office?

Beberapa manfaat:

• Tidak memerlukan Office diinstal
• Dibuat oleh Microsoft = dokumentasi MSDN yang layak
• Hanya satu. Net dll untuk digunakan dalam proyek
• SDK dilengkapi dengan banyak alat seperti diff, validator, dll

Tautan:

• Github
• Pendaratan MSDN Utama
• Halaman awal "Bagaimana Saya ..."
• blogs.MSDN brian_jones mengumumkan SDK
• blogs.MSDN brian_jones menjelaskan SDK yang menangani file besar tanpa mogok (tidak seperti metode DOM)

Saya telah menggunakan dengan sukses proyek open source berikut:

• ExcelPackage untuk format OOXML (Office 2007)

• NPOI untuk format .XLS (Office 2003). NPOI 2.0 (Beta) juga mendukung XLSX.

Lihatlah posting blog saya:

Membuat lembar kerja Excel .XLS dan .XLSX di C #

NPOI dengan Tabel Excel dan Bagan dinamis

Anda dapat menggunakan OLEDB untuk membuat dan memanipulasi file Excel. Periksa ini: Membaca dan Menulis Excel menggunakan OLEDB .

Contoh umum:

using (OleDbConnection conn = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\temp\\test.xls;Extended Properties='Excel 8.0;HDR=Yes'"))
{
  conn.Open();
  OleDbCommand cmd = new OleDbCommand("CREATE TABLE [Sheet1] ([Column1] string, [Column2] string)", conn);
  cmd.ExecuteNonQuery();
}

EDIT - Beberapa lagi tautan:

• Hai, Penulis Naskah! Bagaimana saya bisa membaca dari Excel tanpa menggunakan Excel?
• Cara Menggunakan ADO.NET untuk Mengambil dan Memodifikasi Catatan di Buku Kerja Excel Dengan Visual Basic .NET
• Membaca dan Menulis Excel Spreadsheets Menggunakan ADO.NET C # DbProviderFactory

Solusi komersial, SpreadsheetGear untuk .NET akan melakukannya.

Anda dapat melihat langsung sampel ASP.NET (C # dan VB) di sini dan unduh versi evaluasi di sini .

Penafian: Saya memiliki SpreadsheetGear LLC

Beberapa opsi yang saya gunakan:

Jika XLSX adalah suatu keharusan: ExcelPackage adalah awal yang baik tetapi mati ketika pengembang berhenti bekerja di atasnya. ExML mengambil dari sana dan menambahkan beberapa fitur. ExML bukan pilihan yang buruk, saya masih menggunakannya di beberapa situs web produksi.

Untuk semua proyek baru saya, saya menggunakan NPOI , .NET port dari Apache POI . NPOI 2.0 (Alpha) juga mendukung XLSX.

Opsi yang sangat ringan mungkin menggunakan tabel HTML. Cukup buat tag kepala, badan, dan tabel dalam file, dan simpan sebagai file dengan ekstensi .xls. Ada atribut khusus Microsoft yang dapat Anda gunakan untuk mendesain output, termasuk formula.

Saya menyadari bahwa Anda mungkin tidak mengkodekan ini dalam aplikasi web, tetapi di sini adalah contoh komposisi file Excel melalui tabel HTML. Teknik ini dapat digunakan jika Anda membuat kode aplikasi konsol, aplikasi desktop, atau layanan.

Jika Anda membuat file Excel 2007/2010, cobalah proyek sumber terbuka ini: https://github.com/closedxml/closedxml

Ini menyediakan cara berorientasi objek untuk memanipulasi file (mirip dengan VBA) tanpa berurusan dengan kerepotan Dokumen XML. Ini dapat digunakan oleh bahasa .NET seperti C # dan Visual Basic (VB).

ClosedXML memungkinkan Anda membuat file Excel 2007/2010 tanpa aplikasi Excel. Contoh khas adalah membuat laporan Excel di server web:

var workbook = new XLWorkbook();
var worksheet = workbook.Worksheets.Add("Sample Sheet");
worksheet.Cell("A1").Value = "Hello World!";
workbook.SaveAs("HelloWorld.xlsx");

Anda bisa menggunakan ExcelXmlWriter .

Ini bekerja dengan baik.

Anda sebenarnya mungkin ingin memeriksa kelas interop yang tersedia dalam C # (mis Microsoft.Office.Interop.Excel. Anda mengatakan tidak OLE (yang ini bukan), tetapi kelas interop sangat mudah digunakan. Lihat Dokumentasi C # di sini (Interop untuk Excel dimulai pada halaman 1072 dari C # PDF).

Anda mungkin terkesan jika Anda belum mencobanya.

Harap diingatkan sikap Microsoft tentang hal ini:

Microsoft saat ini tidak merekomendasikan, dan tidak mendukung, Otomatisasi aplikasi Microsoft Office dari aplikasi atau komponen klien non-interaktif yang tidak dijaga (termasuk ASP, ASP.NET, DCOM, dan Layanan NT), karena Office mungkin menunjukkan perilaku yang tidak stabil dan / atau jalan buntu saat Office dijalankan di lingkungan ini.

Berikut adalah perpustakaan C # yang sepenuhnya gratis, yang memungkinkan Anda mengekspor dari DataSet, DataTableatauList<> ke file Excel 2007 .xlsx asli, menggunakan pustaka OpenXML:

http://mikesknowledledgebase.com/pages/CSharp/ExportToExcel.htm

Kode sumber lengkap disediakan - gratis - bersama dengan instruksi, dan aplikasi demo.

Setelah menambahkan kelas ini ke aplikasi Anda, Anda dapat mengekspor DataSet Anda ke Excel hanya dalam satu baris kode:

CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");

Itu tidak menjadi jauh lebih sederhana dari itu ...

Dan itu bahkan tidak memerlukan Excel untuk hadir di server Anda.

Anda dapat mempertimbangkan membuat file menggunakan format XML Spreadsheet 2003 . Ini adalah format XML sederhana menggunakan skema yang terdokumentasi dengan baik .

Anda mungkin ingin melihat GemBox . Spreadsheet .

Mereka memiliki versi gratis dengan semua fitur tetapi dibatasi hingga 150 baris per lembar dan 5 lembar per buku kerja, jika itu sesuai dengan kebutuhan Anda.

Saya belum perlu menggunakannya sendiri, tetapi memang terlihat menarik.

Syncfusion Essential XlsIO dapat melakukan ini. Tidak memiliki ketergantungan pada Microsoft office dan juga memiliki dukungan khusus untuk platform yang berbeda.

• ASP.NET
• ASP.NET MVC
• UWP
• Xamarin
• Formulir WPF dan Windows
• Layanan Windows dan operasi berbasis batch

Contoh kode:

//Creates a new instance for ExcelEngine.
ExcelEngine excelEngine = new ExcelEngine();
//Loads or open an existing workbook through Open method of IWorkbooks
IWorkbook workbook = excelEngine.Excel.Workbooks.Open(fileName);
//To-Do some manipulation|
//To-Do some manipulation
//Set the version of the workbook.
workbook.Version = ExcelVersion.Excel2013;
//Save the workbook in file system as xlsx format
workbook.SaveAs(outputFileName);

Seluruh rangkaian kontrol tersedia secara gratis melalui program lisensi komunitas jika Anda memenuhi syarat (pendapatan kurang dari 1 juta USD). Catatan: Saya bekerja untuk Syncfusion.

Baik,

Anda juga dapat menggunakan perpustakaan pihak ketiga seperti Aspose .

Pustaka ini memiliki manfaat bahwa itu tidak memerlukan Excel untuk diinstal pada mesin Anda yang akan ideal dalam kasus Anda.

OpenXML juga merupakan alternatif yang baik yang membantu menghindari menginstal MS Excel di Server. Open XML SDK 2.0 yang disediakan oleh Microsoft menyederhanakan tugas memanipulasi paket Open XML dan elemen skema Open XML yang mendasarinya dalam sebuah paket. Open XML Application Programming Interface (API) merangkum banyak tugas umum yang dilakukan pengembang pada paket Open XML.

Lihat ini OpenXML: Alternatif yang membantu menghindari menginstal MS Excel di Server

Berbagai pustaka Office 2003 XML yang tersedia tersedia dengan cukup baik untuk file excel yang lebih kecil. Namun, saya menemukan ukuran tipis dari buku kerja besar yang disimpan dalam format XML menjadi masalah. Misalnya, buku kerja tempat saya bekerja dengan ukuran 40 MB dalam format XLSX yang baru (dan tentunya lebih padat) menjadi file XML 360MB.

Sejauh penelitian saya telah mengambil saya, ada dua paket komersial yang memungkinkan output ke format file biner yang lebih lama. Mereka:

• Gembox
• ComponentOne Excel

Tidak ada yang murah (masing-masing 500USD dan 800USD, saya pikir). tetapi keduanya bekerja independen dari Excel itu sendiri.

Apa yang saya ingin tahu tentang adalah modul output Excel untuk orang-orang seperti OpenOffice.org. Saya ingin tahu apakah mereka dapat diangkut dari Jawa ke .Net.

Saya setuju tentang membuat XML Spreadsheets, berikut adalah contoh tentang bagaimana melakukannya untuk C # 3 (semua orang hanya blog tentang hal itu di VB 9: P) http://www.aaron-powell.com/linq-to-xml-to- unggul

Saya baru saja digunakan FlexCel.NET dan menemukannya sebagai pustaka yang sangat baik! Saya tidak mengatakan itu tentang terlalu banyak produk perangkat lunak. Tidak ada gunanya memberikan seluruh penjualan di sini, Anda dapat membaca semua fitur di situs web mereka.

Ini adalah produk komersial, tetapi Anda mendapatkan sumber lengkap jika Anda membelinya. Jadi saya kira Anda bisa mengkompilasinya ke dalam perakitan Anda jika Anda benar-benar menginginkannya. Kalau tidak, itu hanya satu rakitan tambahan untuk xcopy - tidak ada konfigurasi atau instalasi atau semacamnya.

Saya tidak berpikir Anda akan menemukan cara untuk melakukan ini tanpa perpustakaan pihak ketiga sebagai .NET framework, jelas, tidak dibangun untuk mendukungnya dan OLE Automation hanya seluruh dunia yang menyakitkan.

Saya telah menulis kode sederhana untuk mengekspor dataset ke excel tanpa menggunakan objek excel dengan menggunakan System.IO.StreamWriter.

Di bawah ini adalah kode yang akan membaca semua tabel dari dataset dan menuliskannya ke lembar satu per satu. Saya mengambil bantuan dari artikel ini .

public static void exportToExcel(DataSet source, string fileName)
{
        const string endExcelXML = "</Workbook>";
        const string startExcelXML = "<xml version>\r\n<Workbook " +
                 "xmlns=\"urn:schemas-microsoft-com:office:spreadsheet\"\r\n" +
                 " xmlns:o=\"urn:schemas-microsoft-com:office:office\"\r\n " +
                 "xmlns:x=\"urn:schemas-    microsoft-com:office:" +
                 "excel\"\r\n xmlns:ss=\"urn:schemas-microsoft-com:" +
                 "office:spreadsheet\">\r\n <Styles>\r\n " +
                 "<Style ss:ID=\"Default\" ss:Name=\"Normal\">\r\n " +
                 "<Alignment ss:Vertical=\"Bottom\"/>\r\n <Borders/>" +
                 "\r\n <Font/>\r\n <Interior/>\r\n <NumberFormat/>" +
                 "\r\n <Protection/>\r\n </Style>\r\n " +
                 "<Style ss:ID=\"BoldColumn\">\r\n <Font " +
                 "x:Family=\"Swiss\" ss:Bold=\"1\"/>\r\n </Style>\r\n " +
                 "<Style     ss:ID=\"StringLiteral\">\r\n <NumberFormat" +
                 " ss:Format=\"@\"/>\r\n </Style>\r\n <Style " +
                 "ss:ID=\"Decimal\">\r\n <NumberFormat " +
                 "ss:Format=\"0.0000\"/>\r\n </Style>\r\n " +
                 "<Style ss:ID=\"Integer\">\r\n <NumberFormat " +
                 "ss:Format=\"0\"/>\r\n </Style>\r\n <Style " +
                 "ss:ID=\"DateLiteral\">\r\n <NumberFormat " +
                 "ss:Format=\"mm/dd/yyyy;@\"/>\r\n </Style>\r\n " +
                 "</Styles>\r\n ";
        System.IO.StreamWriter excelDoc = null;
        excelDoc = new System.IO.StreamWriter(fileName);

        int sheetCount = 1;
        excelDoc.Write(startExcelXML);
        foreach (DataTable table in source.Tables)
        {
            int rowCount = 0;
            excelDoc.Write("<Worksheet ss:Name=\"" + table.TableName + "\">");
            excelDoc.Write("<Table>");
            excelDoc.Write("<Row>");
            for (int x = 0; x < table.Columns.Count; x++)
            {
                excelDoc.Write("<Cell ss:StyleID=\"BoldColumn\"><Data ss:Type=\"String\">");
                excelDoc.Write(table.Columns[x].ColumnName);
                excelDoc.Write("</Data></Cell>");
            }
            excelDoc.Write("</Row>");
            foreach (DataRow x in table.Rows)
            {
                rowCount++;
                //if the number of rows is > 64000 create a new page to continue output
                if (rowCount == 64000)
                {
                    rowCount = 0;
                    sheetCount++;
                    excelDoc.Write("</Table>");
                    excelDoc.Write(" </Worksheet>");
                    excelDoc.Write("<Worksheet ss:Name=\"" + table.TableName + "\">");
                    excelDoc.Write("<Table>");
                }
                excelDoc.Write("<Row>"); //ID=" + rowCount + "
                for (int y = 0; y < table.Columns.Count; y++)
                {
                    System.Type rowType;
                    rowType = x[y].GetType();
                    switch (rowType.ToString())
                    {
                        case "System.String":
                            string XMLstring = x[y].ToString();
                            XMLstring = XMLstring.Trim();
                            XMLstring = XMLstring.Replace("&", "&");
                            XMLstring = XMLstring.Replace(">", ">");
                            XMLstring = XMLstring.Replace("<", "<");
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                           "<Data ss:Type=\"String\">");
                            excelDoc.Write(XMLstring);
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.DateTime":
                            //Excel has a specific Date Format of YYYY-MM-DD followed by  
                            //the letter 'T' then hh:mm:sss.lll Example 2005-01-31T24:01:21.000
                            //The Following Code puts the date stored in XMLDate 
                            //to the format above
                            DateTime XMLDate = (DateTime)x[y];
                            string XMLDatetoString = ""; //Excel Converted Date
                            XMLDatetoString = XMLDate.Year.ToString() +
                                 "-" +
                                 (XMLDate.Month < 10 ? "0" +
                                 XMLDate.Month.ToString() : XMLDate.Month.ToString()) +
                                 "-" +
                                 (XMLDate.Day < 10 ? "0" +
                                 XMLDate.Day.ToString() : XMLDate.Day.ToString()) +
                                 "T" +
                                 (XMLDate.Hour < 10 ? "0" +
                                 XMLDate.Hour.ToString() : XMLDate.Hour.ToString()) +
                                 ":" +
                                 (XMLDate.Minute < 10 ? "0" +
                                 XMLDate.Minute.ToString() : XMLDate.Minute.ToString()) +
                                 ":" +
                                 (XMLDate.Second < 10 ? "0" +
                                 XMLDate.Second.ToString() : XMLDate.Second.ToString()) +
                                 ".000";
                            excelDoc.Write("<Cell ss:StyleID=\"DateLiteral\">" +
                                         "<Data ss:Type=\"DateTime\">");
                            excelDoc.Write(XMLDatetoString);
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Boolean":
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                        "<Data ss:Type=\"String\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Int16":
                        case "System.Int32":
                        case "System.Int64":
                        case "System.Byte":
                            excelDoc.Write("<Cell ss:StyleID=\"Integer\">" +
                                    "<Data ss:Type=\"Number\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Decimal":
                        case "System.Double":
                            excelDoc.Write("<Cell ss:StyleID=\"Decimal\">" +
                                  "<Data ss:Type=\"Number\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.DBNull":
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                  "<Data ss:Type=\"String\">");
                            excelDoc.Write("");
                            excelDoc.Write("</Data></Cell>");
                            break;
                        default:
                            throw (new Exception(rowType.ToString() + " not handled."));
                    }
                }
                excelDoc.Write("</Row>");
            }
            excelDoc.Write("</Table>");
            excelDoc.Write(" </Worksheet>");
            sheetCount++;
        }


        excelDoc.Write(endExcelXML);
        excelDoc.Close();
    }

Hanya ingin menambahkan referensi lain ke solusi pihak ketiga yang secara langsung mengatasi masalah Anda: http://www.officewriter.com

(Penafian: Saya bekerja untuk SoftArtisans, perusahaan yang membuat OfficeWriter)

IKVM + POI

Atau, Anda dapat menggunakan Interop ...

Berikut cara untuk melakukannya dengan LINQ ke XML, lengkap dengan kode sampel:

Impor dan Ekspor Data Excel dengan cepat dengan LINQ ke XML

Agak rumit, karena Anda harus mengimpor ruang nama dan lain-lain, tetapi itu memungkinkan Anda menghindari ketergantungan eksternal.

(Juga, tentu saja, itu VB. NET, bukan C #, tetapi Anda selalu dapat mengisolasi VB. NET dalam proyek sendiri untuk menggunakan XML Literals, dan melakukan segala sesuatu yang lain dalam C #.)

Beberapa vendor komponen pihak ketiga seperti Infragistics atau Syncfusion menyediakan kemampuan ekspor Excel yang sangat baik yang tidak memerlukan Microsoft Excel untuk diinstal.

Karena vendor ini juga menyediakan komponen kisi UI canggih, komponen ini sangat berguna jika Anda ingin gaya dan tata letak ekspor excel untuk meniru kondisi kisi saat ini dalam antarmuka pengguna aplikasi Anda.

Jika ekspor Anda dimaksudkan untuk dieksekusi di sisi server dengan penekanan pada data yang akan diekspor dan tanpa tautan ke UI, maka saya akan memilih salah satu opsi open source gratis (mis. ExcelLibrary).

Saya sebelumnya telah terlibat dengan proyek-proyek yang berusaha menggunakan otomatisasi sisi server pada suite Microsoft Office. Berdasarkan pengalaman ini saya akan sangat merekomendasikan terhadap pendekatan itu.

public class GridViewExportUtil
{
    public static void Export(string fileName, GridView gv)
    {
        HttpContext.Current.Response.Clear();
        HttpContext.Current.Response.AddHeader(
            "content-disposition", string.Format("attachment; filename={0}", fileName));
        HttpContext.Current.Response.ContentType = "application/ms-excel";

        using (StringWriter sw = new StringWriter())
        {
            using (HtmlTextWriter htw = new HtmlTextWriter(sw))
            {
                //  Create a form to contain the grid
                Table table = new Table();

                //  add the header row to the table
                if (gv.HeaderRow != null)
                {
                    GridViewExportUtil.PrepareControlForExport(gv.HeaderRow);
                    table.Rows.Add(gv.HeaderRow);
                }

                //  add each of the data rows to the table
                foreach (GridViewRow row in gv.Rows)
                {
                    GridViewExportUtil.PrepareControlForExport(row);
                    table.Rows.Add(row);
                }

                //  add the footer row to the table
                if (gv.FooterRow != null)
                {
                    GridViewExportUtil.PrepareControlForExport(gv.FooterRow);
                    table.Rows.Add(gv.FooterRow);
                }

                //  render the table into the htmlwriter
                table.RenderControl(htw);

                //  render the htmlwriter into the response
                HttpContext.Current.Response.Write(sw.ToString());
                HttpContext.Current.Response.End();
            }
        }
    }

    /// <summary>
    /// Replace any of the contained controls with literals
    /// </summary>
    /// <param name="control"></param>
    private static void PrepareControlForExport(Control control)
    {
        for (int i = 0; i < control.Controls.Count; i++)
        {
            Control current = control.Controls[i];
            if (current is LinkButton)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as LinkButton).Text));
            }
            else if (current is ImageButton)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as ImageButton).AlternateText));
            }
            else if (current is HyperLink)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as HyperLink).Text));
            }
            else if (current is DropDownList)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as DropDownList).SelectedItem.Text));
            }
            else if (current is CheckBox)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as CheckBox).Checked ? "True" : "False"));
            }

            if (current.HasControls())
            {
                GridViewExportUtil.PrepareControlForExport(current);
            }
        }
    }
}

Hai solusi ini adalah untuk mengekspor tampilan grid Anda ke file excel Anda mungkin dapat membantu Anda

Anda dapat membuat file Excel yang diformat dengan baik menggunakan perpustakaan ini: http://officehelper.codeplex.com/documentation
Lihat contoh di bawah ini:

using (ExcelHelper helper = new ExcelHelper(TEMPLATE_FILE_NAME, GENERATED_FILE_NAME))
{
    helper.Direction = ExcelHelper.DirectionType.TOP_TO_DOWN;
    helper.CurrentSheetName = "Sheet1";
    helper.CurrentPosition = new CellRef("C3");

    //the template xlsx should contains the named range "header"; use the command "insert"/"name".
    helper.InsertRange("header");

    //the template xlsx should contains the named range "sample1";
    //inside this range you should have cells with these values:
    //<name> , <value> and <comment>, which will be replaced by the values from the getSample()
    CellRangeTemplate sample1 = helper.CreateCellRangeTemplate("sample1", new List<string> {"name", "value", "comment"}); 
    helper.InsertRange(sample1, getSample());

    //you could use here other named ranges to insert new cells and call InsertRange as many times you want, 
    //it will be copied one after another;
    //even you can change direction or the current cell/sheet before you insert

    //typically you put all your "template ranges" (the names) on the same sheet and then you just delete it
    helper.DeleteSheet("Sheet3");
}        

tempat sampel terlihat seperti ini:

private IEnumerable<List<object>> getSample()
{
    var random = new Random();

    for (int loop = 0; loop < 3000; loop++)
    {
        yield return new List<object> {"test", DateTime.Now.AddDays(random.NextDouble()*100 - 50), loop};
    }
}

Cara termudah dan tercepat untuk membuat file Excel dari C # adalah dengan menggunakan Alat Produktivitas Open XML. Open XML Productivity Tool hadir dengan instalasi Open XML SDK. Alat ini membalikkan semua file Excel menjadi kode C #. Kode C # kemudian dapat digunakan untuk menghasilkan kembali file itu.

Gambaran umum proses yang terlibat adalah:

1. Instal Open XML SDK dengan alat.
2. Buat file Excel menggunakan klien Excel terbaru dengan tampilan yang diinginkan. Beri nama DesiredLook.xlsx.
3. Dengan alat terbuka DesiredLook.xlsxdan klik tombol Reflect Code di dekat bagian atas.
4. Kode C # untuk file Anda akan dihasilkan di panel kanan alat. Tambahkan ini ke solusi C # Anda dan hasilkan file dengan tampilan yang diinginkan.

Sebagai bonus, metode ini berfungsi untuk semua file Word dan PowerPoint. Sebagai pengembang C #, Anda kemudian akan membuat perubahan pada kode yang sesuai dengan kebutuhan Anda.

Saya telah mengembangkan aplikasi WPF sederhana di github yang akan berjalan di Windows untuk tujuan ini. Ada kelas placeholder yang disebut GeneratedClasstempat Anda bisa menempelkan kode yang dihasilkan. Jika Anda kembali satu versi file, itu akan menghasilkan file excel seperti ini:

Beberapa otomatisasi Excel yang berguna di C #, Anda dapat temukan dari tautan berikut.

http://csharp.net-informations.com/excel/csharp-excel-tutorial.htm

bolton.

Lihatlah contoh cara membuat file Excel.

Ada beberapa contoh di C # dan VB.NET

Ini mengelola file XSL XSLX dan CSV Excel.

http://www.devtriogroup.com/ExcelJetcell/Samples