Microsoft Office yüklemeden C # içinde nasıl bir Excel (.XLS ve .XLSX) dosyası oluştururum?

Kodu çalıştıran makineye Excel'in yüklenmesini gerektirmeden C # ile bir Excel elektronik tablosunu nasıl oluşturabilirim?

ExcelLibrary adlı bir kitaplık kullanabilirsiniz. Google Code'da yayınlanan ücretsiz, açık kaynaklı bir kütüphane:

ExcelLibrary

Bu, yukarıda bahsettiğiniz PHP ExcelWriter'ın bir bağlantı noktası gibi görünüyor. Henüz yeni .xlsx biçimine yazmaz, ancak bu işlevselliği içine eklemek için çalışıyorlar.

Çok basit, küçük ve kullanımı kolaydır. Ayrıca, Excel verileriyle kolayca çalışmak için DataSets ve DataTable'ları kullanmanıza izin veren bir DataSetHelper vardır.

ExcelLibrary hala daha eski Excel biçimi (.xls dosyaları) için çalışıyor gibi görünüyor, ancak gelecekte daha yeni 2007/2010 formatları için destek ekliyor olabilir.

Yalnızca Excel 2007/2010 biçimindeki dosyalar (.xlsx dosyaları) için çalışan EPPlus'ı da kullanabilirsiniz . Her ikisi ile de çalışan NPOI var.

Yorumlarda belirtildiği gibi her kitaplıkta bilinen birkaç hata vardır. Toplamda, EPPlus zaman geçtikçe en iyi seçim gibi görünüyor. Daha aktif olarak güncelleniyor ve belgeleniyor gibi görünüyor.

Ayrıca, aşağıdaki @ АртёмЦарионов tarafından belirtildiği gibi, EPPlus'ın Pivot Tabloları için desteği vardır ve ExcelLibrary'nin bazı desteği olabilir ( ExcelLibrary'de Pivot tablosu sorunu )

Hızlı başvuru için birkaç bağlantı:
ExcelLibrary - GNU Küçük GPL
EPPlus - GNU Küçük Genel Kamu Lisansı (LGPL)
NPOI - Apache Lisansı

ExcelLibrary için bazı örnek kod:

Veritabanından veri alan ve bu veritabanından bir çalışma kitabı oluşturan bir örnek. ExcelLibrary kodunun alttaki tek satır olduğunu unutmayın:

//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);

Excel dosyasını oluşturmak bu kadar kolaydır. Elle Excel dosyaları da oluşturabilirsiniz, ancak yukarıdaki işlevsellik beni gerçekten etkiledi.

Xlsx biçiminden memnunsanız GitHub projemi EPPlus'ı deneyin . ExcelPackage kaynağından başladı, ancak bugün tam bir yeniden yazma. Aralıkları, hücre stilini, çizelgeleri, şekilleri, resimleri, adlandırılmış aralıkları, Otomatik Filtreyi ve daha birçok şeyi destekler.

Microsoft Office için Açık XML SDK 2.0 kullanmaya ne dersiniz?

Bazı faydaları:

• Office'in yüklü olmasını gerektirmez
• Microsoft tarafından yapılmıştır = İyi MSDN belgeleri
• Projede kullanmak için sadece bir .Net dll
• SDK, diff, validator vb.Gibi birçok araçla birlikte gelir

Bağlantılar:

• Github
• Ana MSDN Açılış
• "Nasıl Yaparım ..." başlangıç ​​sayfası
• blogs.MSDN brian_jones SDK'yı duyurdu
• SDK büyük dosyaları çökmeden işlemeyi açıklayan (DOM yönteminin aksine) brian_jones

Aşağıdaki açık kaynaklı projeleri başarıyla kullandım:

• OOXML formatları için ExcelPackage (Office 2007)

• .XLS biçimi için NPOI (Office 2003). NPOI 2.0 (Beta) XLSX'i de destekler.

Blog gönderilerime bir göz atın:

C # içinde Excel elektronik tabloları .XLS ve .XLSX oluşturma

Excel Tablosu ve dinamik Grafik ile NPOI

Excel dosyalarını oluşturmak ve değiştirmek için OLEDB kullanabilirsiniz. Şunu kontrol edin: OLEDB kullanarak Excel'i okuma ve yazma .

Tipik örnek:

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 - Bazı bağlantılar:

• Hey, Scripting Guy! Excel Kullanmadan Excel'den Nasıl Okuyabilirim?
• Visual Basic .NET ile bir Excel çalışma kitabındaki kayıtları almak ve değiştirmek için ADO.NET nasıl kullanılır
• ADO.NET Kullanarak Excel Elektronik Tablolarını Okuma ve Yazma C # DbProviderFactory

Ticari çözüm, SpreadsheetGear for .NET bunu yapacaktır.

Canlı ASP.NET (C # ve VB) örneklerini burada görebilir ve bir değerlendirme sürümünü buradan indirebilirsiniz .

Feragatname: SpreadsheetGear LLC şirketine sahibim

Kullandığım birkaç seçenek:

XLSX bir zorunluluksa: ExcelPackage iyi bir başlangıçtır, ancak geliştirici üzerinde çalışmayı bıraktığında öldü. ExML oradan aldı ve birkaç özellik ekledi. ExML kötü bir seçenek değil, hala birkaç üretim web sitesinde kullanıyorum.

Tüm yeni projelerim için Apache POI'nin .NET portu olan NPOI kullanıyorum . NPOI 2.0 (Alpha) XLSX'i de destekler.

HTML tablolarını kullanmak için son derece hafif bir seçenek olabilir. Bir dosyada kafa, gövde ve tablo etiketleri oluşturun ve .xls uzantılı bir dosya olarak kaydedin. Çıktıları stilize etmek için kullanabileceğiniz formüller dahil Microsoft'a özgü özellikler vardır.

Bunu bir web uygulamasında kodlamayabileceğinizi anlıyorum, ancak burada bir HTML dosyası aracılığıyla bir Excel dosyasının kompozisyonuna bir örnek . Bu teknik, bir konsol uygulaması, masaüstü uygulaması veya hizmet kodluyorsanız kullanılabilir.

Excel 2007/2010 dosyaları oluşturuyorsanız bu açık kaynak projesini deneyin: https://github.com/closedxml/closedxml

XML Belgelerinin zorluklarıyla uğraşmadan dosyaları (VBA'ya benzer) manipüle etmek için nesne yönelimli bir yol sağlar. C # ve Visual Basic (VB) gibi herhangi bir .NET dili tarafından kullanılabilir.

ClosedXML, Excel uygulaması olmadan Excel 2007/2010 dosyaları oluşturmanıza olanak tanır. Tipik bir örnek, bir web sunucusunda Excel raporları oluşturmaktır:

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

ExcelXmlWriter kullanabilirsiniz .

İyi çalışıyor.

Aslında C # 'da bulunan birlikte çalışma sınıflarını kontrol etmek isteyebilirsiniz (örn Microsoft.Office.Interop.Excel. OLE diye bir şey söylemezsiniz (ki bu böyle değildir), ancak birlikte çalışma sınıflarının kullanımı çok kolaydır. Burada C # Belgelerine bakın (Interop for Excel başlar) sayfa 1072).

Onları denemediyseniz etkilenmiş olabilirsiniz.

Lütfen Microsoft'un bu konudaki tutumuna dikkat edin:

Microsoft şu anda herhangi bir katılımsız, etkileşimli olmayan istemci uygulaması veya bileşeninden (ASP, ASP.NET, DCOM ve NT Hizmetleri dahil) Microsoft Office uygulamalarının Otomasyonunu önermemektedir ve desteklememektedir, çünkü Office kararsız davranış ve / veya Office bu ortamda çalıştırıldığında kilitlenme.

Burada bir dışa sağlayan tamamen ücretsiz C # kütüphanesi, var DataSet, DataTableveya List<>açık XML kütüphaneleri kullanılarak orijinal bir Excel 2007 .xlsx dosyası içine:

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

Tam kaynak kodu - ücretsiz olarak - talimatlar ve bir demo uygulaması ile birlikte sağlanır.

Bu sınıfı uygulamanıza ekledikten sonra, DataSet'inizi yalnızca bir kod satırında Excel'e aktarabilirsiniz:

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

Bundan daha basit olamaz ...

Ve Excel'in sunucunuzda bulunmasını bile gerektirmez.

XML E-Tablo 2003 biçimini kullanarak dosyalarınızı oluşturmayı düşünebilirsiniz . Bu, iyi belgelenmiş bir şema kullanan basit bir XML biçimidir .

GemBox.Spreadsheet'e bakmak isteyebilirsiniz .

İhtiyaçlarınız dahilinde ise, tüm özelliklere sahip ücretsiz bir sürümleri vardır, ancak sayfa başına 150 satır ve çalışma kitabı başına 5 sayfa ile sınırlıdır.

Henüz kendim kullanmam gerekmiyordu, ama ilginç görünüyor.

Syncfusion Essential XlsIO bunu yapabilir. Microsoft Office'e bağımlı değildir ve ayrıca farklı platformlar için özel bir desteği vardır.

• ASP.NET
• ASP.NET MVC
• UWP
• Xamarin
• WPF ve Windows Formları
• Windows Hizmeti ve toplu işlem işlemleri

Kod örneği:

//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);

Hak sahibi olursanız , tüm kontrol paketi topluluk lisans programı aracılığıyla ücretsiz olarak kullanılabilir (gelirden 1 milyon ABD dolarından az). Not: Syncfusion için çalışıyorum.

İyi,

Aspose gibi bir üçüncü taraf kitaplığı da kullanabilirsiniz .

Bu kütüphane, Excel'in makinenize yüklenmesini gerektirmemesi avantajına sahiptir, bu da sizin durumunuz için idealdir.

OpenXML, MS Excel'in Sunucuya yüklenmesini önlemeye yardımcı olan iyi bir alternatiftir. Microsoft tarafından sağlanan Open XML SDK 2.0, Open XML paketlerini ve bir paket içindeki temel Açık XML şema öğelerini değiştirme görevini basitleştirir. Açık XML Uygulama Programlama Arabirimi (API), geliştiricilerin Açık XML paketlerinde gerçekleştirdiği birçok genel görevi içerir.

Bunu inceleyin OpenXML: Sunucuya MS Excel'i yüklemekten kaçınmaya yardımcı olan alternatif

Çeşitli Office 2003 XML kitaplıkları küçük excel dosyaları için oldukça iyi çalışır. Ancak, XML biçiminde kaydedilmiş büyük bir çalışma kitabının boyutunun bir sorun olduğunu düşünüyorum. Örneğin, birlikte çalıştığım bir çalışma kitabı yeni (ve kuşkusuz daha sıkı bir şekilde paketlenmiş) XLSX biçiminde 40 MB olacaktır.

Araştırmam beni götürdüğü kadarıyla, eski ikili dosya formatlarına çıktıya izin veren iki ticari paket var. Onlar:

• Gembox
• ComponentOne Excel

İkisi de ucuz değil (sırasıyla 500USD ve 800USD). ancak her ikisi de Excel'in kendisinden bağımsız çalışır.

Merak ettiğim şey OpenOffice.org gibi Excel çıktı modülü. Acaba Java'dan .Net'e taşınabilir mi?

XML E-Tablolar oluşturmayı kabul ediyorum, C # 3 için nasıl yapılacağına dair bir örnek (herkes sadece VB 9: P'de blog yazıyor) http://www.aaron-powell.com/linq-to-xml-to- excel

Son zamanlarda FlexCel.NET'i kullandım ve mükemmel bir kütüphane ! Çok fazla yazılım ürünü hakkında bunu söylemiyorum. Tüm satış konuşmasını burada vermenin bir anlamı yok, web sitesindeki tüm özellikleri okuyabilirsiniz.

Ticari bir üründür, ancak satın alırsanız tam kaynağı alırsınız. Bu yüzden eğer gerçekten isteseydiniz bunu derlemenize derleyebilirsiniz. Aksi takdirde xcopy için sadece bir ekstra montaj - yapılandırma veya kurulum veya bunun gibi bir şey yok.

Üçüncü taraf kütüphaneler olmadan bunu yapmanın herhangi bir yolunu bulacağınızı sanmıyorum.

System.IO.StreamWriter kullanarak excel nesnesini kullanmadan excel veri kümesini vermek için basit bir kod yazdım.

Aşağıda, tüm tabloları veri kümesinden okuyacak ve tek tek sayfalara yazacak olan kod bulunmaktadır. Bu makaleden yardım aldım .

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();
    }

Yalnızca sorununuzu doğrudan ele alan bir üçüncü taraf çözümüne başka bir referans eklemek istiyorum: http://www.officewriter.com

(Feragatname: OfficeWriter yapan SoftArtisans için çalışıyorum)

IKVM + İÇN

Veya Interop'u kullanabilirsiniz ...

Örnek kodla birlikte, LINQ to XML ile yapmanın bir yolu:

LINQ ile Excel Verilerini XML'ye Hızla İçeri ve Dışarı Aktarma

İsim alanlarını vb. İçe aktarmanız gerektiğinden biraz karmaşıktır, ancak harici bağımlılıklardan kaçınmanıza izin verir.

(Ayrıca, elbette, C # değil VB .NET'dir, ancak VB .NET öğelerini her zaman kendi projesinde XML Değişmezlerini kullanmak ve C # 'da her şeyi yapmak için izole edebilirsiniz.)

Infragistics veya Syncfusion gibi bazı üçüncü taraf bileşen satıcıları, Microsoft Excel'in yüklenmesini gerektirmeyen çok iyi Excel dışa aktarma özellikleri sağlar.

Bu satıcılar ayrıca gelişmiş kullanıcı arabirimi ızgarası bileşenleri sağladığından, bir excel dışa aktarmanın stili ve düzeninin, uygulamanızın kullanıcı arabirimindeki bir ızgaranın geçerli durumunu taklit etmesini istiyorsanız, bu bileşenler özellikle kullanışlıdır.

Dışa aktarma işleminizin, dışa aktarılacak verilere vurgu yapılarak ve kullanıcı arayüzüne bağlantı olmadan sunucu tarafında yürütülmesi amaçlanıyorsa, ücretsiz açık kaynak seçeneklerinden birini (örneğin ExcelLibrary) tercih ederim.

Daha önce Microsoft Office paketinde sunucu tarafı otomasyonu kullanmaya çalışan projelerle ilgilenmiştim. Bu deneyime dayanarak, bu yaklaşıma karşı şiddetle tavsiye ediyorum.

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);
            }
        }
    }
}

Merhaba bu çözüm, ızgara görünümünüzü excel dosyanıza dışa aktarmaktır.

Bu kitaplığı kullanarak güzel biçimlendirilmiş Excel dosyaları oluşturabilirsiniz: http://officehelper.codeplex.com/documentation
Aşağıdaki örneğe bakın:

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");
}        

nerede örnek böyle bakmak:

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};
    }
}

C #'dan bir Excel dosyası oluşturmanın en basit ve en hızlı yolu Açık XML Üretkenlik Aracı'nı kullanmaktır. Açık XML Üretkenlik Aracı, Açık XML SDK yüklemesi ile birlikte gelir. Araç tersine herhangi bir Excel dosyasını C # koduna dönüştürür. C # kodu daha sonra bu dosyayı yeniden oluşturmak için kullanılabilir.

İlgili sürece genel bir bakış:

1. Open XML SDK'sını araçla yükleyin.
2. İstediğiniz görünüme sahip en son Excel istemcisini kullanarak bir Excel dosyası oluşturun. Ad verin DesiredLook.xlsx.
3. Araç açıkken DesiredLook.xlsxüst taraftaki Kodu Yansıt düğmesini tıklayın.
4. Dosyanızın C # kodu aracın sağ bölmesinde oluşturulur. Bunu C # çözümünüze ekleyin ve istediğiniz görünüme sahip dosyalar oluşturun.

Bonus olarak, bu yöntem herhangi bir Word ve PowerPoint dosyası için çalışır. C # geliştiricisi olarak, gereksinimlerinize uyacak şekilde kodda değişiklikler yaparsınız.

Github üzerinde bu amaçla Windows üzerinde çalışacak basit bir WPF uygulaması geliştirdim . GeneratedClassOluşturulan kodu yapıştırabileceğiniz bir yer tutucu sınıf var . Dosyanın bir sürümünü geri giderseniz, böyle bir excel dosyası oluşturur:

C # bazı yararlı Excel otomasyonu, u aşağıdaki bağlantıdan bulabilirsiniz.

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

bolton.

Excel dosyalarının nasıl oluşturulacağına ilişkin örneklere bakın.

İçinde örnekler var C # ve VB.NET'te

XSL XSLX ve CSV Excel dosyalarını yönetir.

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