Wie erstelle ich eine Excel-Datei (.XLS und .XLSX) in C #, ohne Microsoft Office zu installieren?

Wie kann ich eine Excel-Tabelle mit C # erstellen, ohne dass Excel auf dem Computer installiert werden muss, auf dem der Code ausgeführt wird?

Sie können eine Bibliothek namens ExcelLibrary verwenden. Es ist eine kostenlose Open-Source-Bibliothek, die auf Google Code veröffentlicht wird:

ExcelLibrary

Dies scheint ein Port des oben erwähnten PHP ExcelWriter zu sein. Es wird noch nicht in das neue XLSX-Format geschrieben, aber sie arbeiten daran, diese Funktionalität hinzuzufügen.

Es ist sehr einfach, klein und einfach zu bedienen. Außerdem verfügt es über einen DataSetHelper, mit dem Sie DataSets und DataTables verwenden können, um problemlos mit Excel-Daten zu arbeiten.

ExcelLibrary scheint immer noch nur für das ältere Excel-Format (XLS-Dateien) zu funktionieren, unterstützt jedoch möglicherweise in Zukunft neuere Formate für 2007/2010.

Sie können auch EPPlus verwenden , das nur für Dateien im Excel 2007/2010-Format (XLSX-Dateien) funktioniert. Es gibt auch NPOI, die mit beiden funktioniert.

Es gibt einige bekannte Fehler in jeder Bibliothek, wie in den Kommentaren angegeben. Insgesamt scheint EPPlus im Laufe der Zeit die beste Wahl zu sein. Es scheint auch aktiver aktualisiert und dokumentiert zu werden.

Wie von @ АртёмЦарионов unten angegeben, unterstützt EPPlus Pivot-Tabellen und ExcelLibrary unterstützt möglicherweise ( Pivot-Tabellenproblem in ExcelLibrary )

Hier einige Links zur schnellen Referenz:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Apache-Lizenz

Hier ein Beispielcode für ExcelLibrary:

Hier ist ein Beispiel, in dem Daten aus einer Datenbank entnommen und daraus eine Arbeitsmappe erstellt werden. Beachten Sie, dass der ExcelLibrary-Code die einzelne Zeile unten ist:

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

So einfach ist das Erstellen der Excel-Datei. Sie können Excel-Dateien auch manuell erstellen, aber die oben genannten Funktionen haben mich wirklich beeindruckt.

Wenn Sie mit dem xlsx-Format zufrieden sind, probieren Sie mein GitHub-Projekt EPPlus aus . Es begann mit der Quelle von ExcelPackage, aber heute ist es ein komplettes Umschreiben. Es unterstützt Bereiche, Zellenstil, Diagramme, Formen, Bilder, benannte Bereiche, AutoFilter und viele andere Dinge.

Und was ist mit Open XML SDK 2.0 für Microsoft Office?

Einige Vorteile:

• Erfordert keine Installation von Office
• Hergestellt von Microsoft = anständige MSDN-Dokumentation
• Nur eine .Net-DLL zur Verwendung im Projekt
• Das SDK enthält viele Tools wie Diff, Validator usw.

Links:

• Github
• Haupt-MSDN-Landung
• Startseite "Wie mache ich ..."
• blogs.MSDN brian_jones kündigt SDK an
• blogs.MSDN brian_jones beschreibt das SDK, das große Dateien ohne Absturz verarbeitet (im Gegensatz zur DOM-Methode).

Ich habe mit Erfolg die folgenden Open Source-Projekte verwendet:

• ExcelPackage für OOXML-Formate (Office 2007)

• NPOI für das XLS-Format (Office 2003). NPOI 2.0 (Beta) unterstützt auch XLSX.

Schauen Sie sich meine Blog-Beiträge an:

Erstellen von Excel-Tabellen .XLS und .XLSX in C #

NPOI mit Excel-Tabelle und dynamischem Diagramm

Mit OLEDB können Sie Excel-Dateien erstellen und bearbeiten. Überprüfen Sie Folgendes : Lesen und Schreiben von Excel mit OLEDB .

Typisches Beispiel:

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 - Einige weitere Links:

• Hey, Scripting Guy! Wie kann ich aus Excel lesen, ohne Excel zu verwenden?
• So verwenden Sie ADO.NET zum Abrufen und Ändern von Datensätzen in einer Excel-Arbeitsmappe mit Visual Basic .NET
• Lesen und Schreiben von Excel-Tabellen mit ADO.NET C # DbProviderFactory

Die kommerzielle Lösung SpreadsheetGear für .NET wird dies tun.

Sie können Live - ASP.NET (C # und VB) Proben siehe hier und laden Sie eine Testversion hier .

Haftungsausschluss: Ich besitze SpreadsheetGear LLC

Einige Optionen, die ich verwendet habe:

Wenn XLSX ein Muss ist: ExcelPackage ist ein guter Anfang, aber es ist ausgestorben, als der Entwickler aufgehört hat, daran zu arbeiten. ExML nahm von dort auf und fügte einige Funktionen hinzu. ExML ist keine schlechte Option, ich verwende es immer noch auf einigen Produktionswebsites.

Für alle meine neuen Projekte verwende ich jedoch NPOI , den .NET-Port von Apache POI . NPOI 2.0 (Alpha) unterstützt auch XLSX.

Eine extrem leichte Option kann die Verwendung von HTML-Tabellen sein. Erstellen Sie einfach Kopf-, Text- und Tabellen-Tags in einer Datei und speichern Sie sie als Datei mit der Erweiterung .xls. Es gibt Microsoft-spezifische Attribute, mit denen Sie die Ausgabe formatieren können, einschließlich Formeln.

Mir ist klar, dass Sie dies möglicherweise nicht in einer Webanwendung codieren, aber hier ist ein Beispiel für die Zusammensetzung einer Excel-Datei über eine HTML-Tabelle. Diese Technik kann verwendet werden, wenn Sie eine Konsolen-App, eine Desktop-App oder einen Dienst codieren.

Wenn Sie Excel 2007/2010-Dateien erstellen, probieren Sie dieses Open Source-Projekt aus: https://github.com/closedxml/closedxml

Es bietet eine objektorientierte Möglichkeit, die Dateien (ähnlich wie VBA) zu bearbeiten, ohne die Probleme von XML-Dokumenten zu lösen. Es kann von jeder .NET-Sprache wie C # und Visual Basic (VB) verwendet werden.

Mit ClosedXML können Sie Excel 2007/2010-Dateien ohne die Excel-Anwendung erstellen. Das typische Beispiel ist das Erstellen von Excel-Berichten auf einem Webserver:

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

Sie können ExcelXmlWriter verwenden .

Es funktioniert gut.

Vielleicht möchten Sie tatsächlich die in C # verfügbaren Interop-Klassen überprüfen (z Microsoft.Office.Interop.Excel. B. Sie sagen kein OLE (was dies nicht ist), aber die Interop-Klassen sind sehr einfach zu verwenden. Lesen Sie hier die C # -Dokumentation (Interop für Excel beginnt am) Seite 1072 des C # PDF).

Sie könnten beeindruckt sein, wenn Sie sie nicht ausprobiert haben.

Bitte seien Sie vor der Haltung von Microsoft zu diesem Thema gewarnt :

Microsoft empfiehlt und unterstützt derzeit keine Automatisierung von Microsoft Office-Anwendungen aus unbeaufsichtigten, nicht interaktiven Clientanwendungen oder -komponenten (einschließlich ASP-, ASP.NET-, DCOM- und NT-Diensten), da Office möglicherweise instabiles Verhalten und / oder instabiles Verhalten aufweist oder Deadlock, wenn Office in dieser Umgebung ausgeführt wird.

Hier ist eine völlig freie C # Bibliothek, die Sie von einem exportieren können DataSet, DataTableoder List<>in eine echte Excel 2007 XLSX - Datei, die OpenXML - Bibliotheken:

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

Der vollständige Quellcode wird kostenlos zusammen mit Anweisungen und einer Demo-Anwendung bereitgestellt.

Nachdem Sie diese Klasse zu Ihrer Anwendung hinzugefügt haben, können Sie Ihr DataSet in nur einer Codezeile nach Excel exportieren:

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

Einfacher geht es nicht ...

Und es ist nicht einmal erforderlich, dass Excel auf Ihrem Server vorhanden ist.

Sie können Ihre Dateien im XML Spreadsheet 2003- Format erstellen . Dies ist ein einfaches XML-Format, das ein gut dokumentiertes Schema verwendet .

Vielleicht möchten Sie einen Blick auf GemBox.Spreadsheet werfen .

Sie haben eine kostenlose Version mit allen Funktionen, sind jedoch auf 150 Zeilen pro Blatt und 5 Blätter pro Arbeitsmappe beschränkt, wenn dies Ihren Anforderungen entspricht.

Ich musste es noch nicht selbst benutzen, sieht aber interessant aus.

Syncfusion Essential XlsIO kann dies tun. Es ist nicht von Microsoft Office abhängig und bietet spezifische Unterstützung für verschiedene Plattformen.

• ASP.NET
• ASP.NET MVC
• UWP
• Xamarin
• WPF und Windows Forms
• Windows-Dienst und stapelbasierte Vorgänge

Codebeispiel:

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

Die gesamte Kontrollsuite ist über das Community-Lizenzprogramm kostenlos verfügbar , wenn Sie sich qualifizieren (weniger als 1 Million USD Umsatz). Hinweis: Ich arbeite für Syncfusion.

Gut,

Sie können auch eine Drittanbieter-Bibliothek wie Aspose verwenden .

Diese Bibliothek hat den Vorteil, dass Excel nicht auf Ihrem Computer installiert werden muss, was in Ihrem Fall ideal wäre.

OpenXML ist auch eine gute Alternative, um die Installation von MS Excel auf einem Server zu vermeiden. Das von Microsoft bereitgestellte Open XML SDK 2.0 vereinfacht die Bearbeitung von Open XML-Paketen und den zugrunde liegenden Open XML-Schemaelementen innerhalb eines Pakets. Die Open XML Application Programming Interface (API) enthält viele allgemeine Aufgaben, die Entwickler für Open XML-Pakete ausführen.

Schauen Sie sich OpenXML: Alternative an, um die Installation von MS Excel auf dem Server zu vermeiden

Die verschiedenen verfügbaren Office 2003-XML-Bibliotheken eignen sich recht gut für kleinere Excel-Dateien. Ich finde jedoch die schiere Größe einer großen Arbeitsmappe, die im XML-Format gespeichert ist, ein Problem. Eine Arbeitsmappe, mit der ich arbeite, ist beispielsweise 40 MB im neuen (und zugegebenermaßen dichter gepackten) XLSX-Format und wird zu einer 360 MB XML-Datei.

Nach meinen Recherchen gibt es zwei kommerzielle Pakete, die die Ausgabe in ältere Binärdateiformate ermöglichen. Sie sind:

• Gembox
• ComponentOne Excel

Weder sind billig (500 USD bzw. 800 USD, denke ich). Beide arbeiten jedoch unabhängig von Excel.

Was mich interessieren würde, ist das Excel-Ausgabemodul für OpenOffice.org. Ich frage mich, ob sie von Java nach .Net portiert werden können.

Ich bin damit einverstanden, XML-Tabellen zu erstellen. Hier ist ein Beispiel, wie dies für C # 3 gemacht wird (jeder bloggt nur in VB 9: P darüber). Http://www.aaron-powell.com/linq-to-xml-to- übertreffen

Ich habe erst kürzlich FlexCel.NET verwendet und festgestellt, dass es sich um eine hervorragende Bibliothek handelt! Ich sage das nicht über zu viele Softwareprodukte. Es macht keinen Sinn, hier das gesamte Verkaufsgespräch zu führen. Sie können alle Funktionen auf ihrer Website lesen.

Es ist ein kommerzielles Produkt, aber Sie erhalten die vollständige Quelle, wenn Sie es kaufen. Ich nehme an, Sie könnten es in Ihre Assembly kompilieren, wenn Sie es wirklich wollten. Ansonsten ist es nur eine zusätzliche Baugruppe für xcopy - keine Konfiguration oder Installation oder ähnliches.

Ich glaube nicht, dass Sie ohne Bibliotheken von Drittanbietern einen Weg finden werden, dies zu tun, da .NET Framework offensichtlich keine Unterstützung dafür eingebaut hat und OLE Automation nur eine ganze Welt voller Schmerzen ist.

Ich habe einen einfachen Code zum Exportieren eines Datasets nach Excel geschrieben, ohne ein Excel-Objekt mithilfe von System.IO.StreamWriter zu verwenden.

Unten finden Sie den Code, mit dem alle Tabellen aus dem Datensatz gelesen und einzeln in die Blätter geschrieben werden. Ich habe Hilfe von diesem Artikel genommen .

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

Sie möchten lediglich einen weiteren Verweis auf eine Drittanbieterlösung hinzufügen, die Ihr Problem direkt behebt: http://www.officewriter.com

(Haftungsausschluss: Ich arbeite für SoftArtisans, das Unternehmen, das OfficeWriter herstellt.)

IKVM + POI

Oder Sie könnten die Interop verwenden ...

Hier ist eine Möglichkeit, dies mit LINQ to XML zu tun, einschließlich Beispielcode:

Schnelles Importieren und Exportieren von Excel-Daten mit LINQ nach XML

Es ist ein wenig komplex, da Sie Namespaces usw. importieren müssen, aber Sie können damit externe Abhängigkeiten vermeiden.

(Natürlich ist es auch VB .NET, nicht C #, aber Sie können das VB .NET-Material jederzeit in einem eigenen Projekt isolieren, um XML-Literale zu verwenden, und alles andere in C # ausführen.)

Einige Anbieter von Komponenten von Drittanbietern wie Infragistics oder Syncfusion bieten sehr gute Excel-Exportfunktionen, für die keine Installation von Microsoft Excel erforderlich ist.

Da diese Anbieter auch erweiterte UI-Rasterkomponenten bereitstellen, sind diese Komponenten besonders praktisch, wenn Stil und Layout eines Excel-Exports den aktuellen Status eines Rasters in der Benutzeroberfläche Ihrer Anwendung nachahmen sollen.

Wenn Ihr Export serverseitig ausgeführt werden soll, wobei der Schwerpunkt auf den zu exportierenden Daten liegt und keine Verknüpfung zur Benutzeroberfläche besteht, würde ich eine der kostenlosen Open Source-Optionen (z. B. ExcelLibrary) wählen.

Ich war zuvor an Projekten beteiligt, bei denen versucht wurde, die serverseitige Automatisierung in der Microsoft Office-Suite zu verwenden. Aufgrund dieser Erfahrung würde ich diesen Ansatz dringend empfehlen.

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

Hallo, diese Lösung besteht darin, Ihre Rasteransicht in Ihre Excel-Datei zu exportieren. Dies könnte Ihnen helfen

Mit dieser Bibliothek können Sie gut formatierte Excel-Dateien erstellen: http://officehelper.codeplex.com/documentation
Siehe Beispiel unten:

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

wo Probe so aussehen:

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

Der einfachste und schnellste Weg, eine Excel-Datei aus C # zu erstellen, ist die Verwendung des Open XML Productivity Tool. Das Open XML Productivity Tool wird mit der Open XML SDK-Installation geliefert. Das Tool entwickelt jede Excel-Datei in C # -Code zurück. Der C # -Code kann dann verwendet werden, um diese Datei neu zu generieren.

Ein Überblick über den Prozess ist:

1. Installieren Sie das Open XML SDK mit dem Tool.
2. Erstellen Sie eine Excel-Datei mit dem neuesten Excel-Client mit dem gewünschten Aussehen. Nennen Sie es DesiredLook.xlsx.
3. Öffnen DesiredLook.xlsxSie bei geöffnetem Werkzeug die Schaltfläche Code reflektieren oben.
4. Der C # -Code für Ihre Datei wird im rechten Bereich des Tools generiert. Fügen Sie dies Ihrer C # -Lösung hinzu und generieren Sie Dateien mit dem gewünschten Aussehen.

Als Bonus funktioniert diese Methode für alle Word- und PowerPoint-Dateien. Als C # -Entwickler nehmen Sie dann Änderungen am Code vor, die Ihren Anforderungen entsprechen.

Ich habe eine einfache WPF-App auf Github entwickelt, die zu diesem Zweck unter Windows ausgeführt wird. Es gibt eine Platzhalterklasse namens, GeneratedClassin die Sie den generierten Code einfügen können. Wenn Sie eine Version der Datei zurückgehen, wird eine Excel-Datei wie folgt generiert:

Einige nützliche Excel-Automatisierungen in C # finden Sie unter folgendem Link.

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

Bolton.

Schauen Sie sich Beispiele zum Erstellen von Excel-Dateien an.

Es gibt Beispiele in C # und VB.NET

Es verwaltet XSL XSLX- und CSV-Excel-Dateien.

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