eine Excel-Datei in ASP.NET zu erzeugen [geschlossen]

StackOverflow https://stackoverflow.com/questions/150339

  •  02-07-2019
  •  | 
  •  

Frage

Ich bin über einen Abschnitt zu einer ASP.NET-Anwendung (VB.NET Code-Behind) hinzufügen, die einem Benutzer zu ermöglichen, werden die Daten, um sie als Excel-Datei zu erhalten zurückgegeben, die ich auf Datenbank-Daten erzeugen basiert wird. Zwar gibt es mehr Möglichkeiten, dies zu tun, jeder hat seine eigenen Nachteile. Wie würden Sie die Daten zurückgeben? Ich bin auf der Suche nach etwas, das so sauber und einfach wie möglich ist.

War es hilfreich?

Lösung

CSV

Vorteile:

  • Einfache

Nachteile:

  • Es kann in anderen Orten oder in verschiedenen Excel-Konfigurationen (d Listentrennzeichen)
    • nicht funktionieren
  • Kann nicht anwenden Formatierung, Formeln, usw.

HTML

Vorteile:

  • Still ziemlich einfach
  • Unterstützt einfache Formatierungen und Formeln

Nachteile:

  • Sie haben die Datei als xls benennen und Excel können Sie warnen, eine nicht nativen Excel-Datei
    • über das Öffnen
  • Ein Arbeitsblatt pro Arbeitsmappe

OpenXML (Office 2007 XLSX)

Vorteile:

  • Native Excel-Format
  • Unterstützt alle Excel-Funktionen
  • Sie nicht erfordert eine Installation Kopie von Excel
  • Kann Pivot-Tabellen erzeugen
  • erzeugt werden unter Verwendung von Open-Source-Projekt EPPlus

Nachteile:

  • Eingeschränkte Kompatibilität außerhalb Excel 2007 (sollte kein Problem heutzutage sein)
  • Komplizierte, wenn Sie einen Dritten Komponente verwenden

SpreadsheetML (offenes Format XML)

Vorteile:

  • Einfache im Vergleich zu nativen Excel-Format
  • Unterstützt die meisten Excel-Funktionen: Formatierung, Stile, Formeln, mehrere Blätter pro Arbeitsmappe
  • Excel muss nicht installiert werden, es zu benutzen
  • Keine Drittanbieter-Bibliotheken erforderlich - einfach schreiben Sie Ihre xml
  • Die Dokumente können von Excel XP / 2003/2007
    • geöffnet werden

Nachteile:

  • Der Mangel an guter Dokumentation
  • Nicht in älteren Versionen von Excel (vor 2000) unterstützt
  • Schreib nur, dass, wenn Sie es öffnen und Änderungen von Excel es in native Excel umgewandelt wird.

XLS (erzeugt durch Dritte Komponente)

Vorteile:

  • Erzeugen nativer Excel mit allen Formatierungen Datei, Formeln, etc.

Nachteile:

  • Kosten Geld
  • Fügen Sie Abhängigkeiten

COM Interop

Vorteile:

  • verwendet native Microsoft Bibliotheken
  • Lesen Sie Unterstützung für native Dokumente

Nachteile:

  • Sehr langsam
  • Abhängigkeit / Version entsprechende Vorgänge
  • Concurrency / Probleme der Datenintegrität für die Verwendung im Web beim Lesen
  • Sehr langsam
  • Skalierung Probleme für die Verwendung im Web (abweichend von Concurrency): Notwendigkeit, viele Fälle von schwerer Excel-Anwendung auf dem Server
    • erstellen
  • Erfordert Windows
  • Habe ich erwähnt, dass es langsam?

Andere Tipps

Sie können die Ausgabe der Daten als HTML-Tabellenzellen, halten eine .xls oder .xlsx Erweiterung auf, und Excel wird es geöffnet, als ob es ein nativer Dokumente waren. Sie können sogar einige begrenzte Formatierungs- und Formelberechnungen auf diese Weise tun, so ist es viel mächtiger als CSV. Auch eine HTML-Tabelle zur Ausgabe sollte ziemlich einfach sein, von einer Web-Plattform wie ASP.Net zu tun;)

Wenn Sie mehrere Arbeitsblätter oder benannte Arbeitsblätter in Ihrer Excel-Arbeitsmappe benötigen, können Sie etwas ähnliches über ein XML-Schema tun SpreadSheetML genannt. Dies ist nicht das neue Format, das mit Office ausgeliefert 2007, aber etwas ganz anderes, das so weit zurück wie Excel 2000. Der einfachste Weg, zu erklären, funktioniert, wie es funktioniert mit einem Beispiel: 

<?xml version="1.0"?>
<?mso-application progid="Excel.Sheet"?> 
<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"
        xmlns:o="urn:schemas-microsoft-com:office:office"
        xmlns:x="urn:schemas-microsoft-com:office:excel"
        xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
        xmlns:html="http://www.w3.org/TR/REC-html40">
<DocumentProperties xmlns="urn:schemas-microsoft-com:office:office">
      <Author>Your_name_here</Author>
      <LastAuthor>Your_name_here</LastAuthor>
      <Created>20080625</Created>
      <Company>ABC Inc</Company>
      <Version>10.2625</Version>
</DocumentProperties>
<ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">
        <WindowHeight>6135</WindowHeight>
        <WindowWidth>8445</WindowWidth>
        <WindowTopX>240</WindowTopX>
        <WindowTopY>120</WindowTopY>
        <ProtectStructure>False</ProtectStructure>
        <ProtectWindows>False</ProtectWindows>
</ExcelWorkbook>

<Styles>
      <Style ss:ID="Default" ss:Name="Normal">
            <Alignment ss:Vertical="Bottom" />
            <Borders />
            <Font />
            <Interior />
            <NumberFormat />
            <Protection />
      </Style>
</Styles>

<Worksheet ss:Name="Sample Sheet 1">
<Table ss:ExpandedColumnCount="2" x:FullColumns="1" x:FullRows="1" ID="Table1">
<Column ss:Width="150" />
<Column ss:Width="200" />
<Row>
      <Cell><Data ss:Type="Number">1</Data></Cell>
      <Cell><Data ss:Type="Number">2</Data></Cell>
</Row>
<Row>
      <Cell><Data ss:Type="Number">3</Data></Cell>
      <Cell><Data ss:Type="Number">4</Data></Cell>
</Row>
<Row>
      <Cell><Data ss:Type="Number">5</Data></Cell>
      <Cell><Data ss:Type="Number">6</Data></Cell>
</Row>
<Row>
      <Cell><Data ss:Type="Number">7</Data></Cell>
      <Cell><Data ss:Type="Number">8</Data></Cell>
</Row>
</Table>
</Worksheet>

<Worksheet ss:Name="Sample Sheet 2">
<Table ss:ExpandedColumnCount="2" x:FullColumns="1" x:FullRows="1" ID="Table2">
<Column ss:Width="150" />
<Column ss:Width="200" />
<Row>
      <Cell><Data ss:Type="String">A</Data></Cell>
      <Cell><Data ss:Type="String">B</Data></Cell>
</Row>
<Row>
      <Cell><Data ss:Type="String">C</Data></Cell>
      <Cell><Data ss:Type="String">D</Data></Cell>
</Row>
<Row>
      <Cell><Data ss:Type="String">E</Data></Cell>
      <Cell><Data ss:Type="String">F</Data></Cell>
</Row>
<Row>
      <Cell><Data ss:Type="String">G</Data></Cell>
      <Cell><Data ss:Type="String">H</Data></Cell>
</Row>
</Table>
</Worksheet>
</Workbook>

Wenn aus einem Datatable : 

public static void DataTabletoXLS(DataTable DT, string fileName)
{
    HttpContext.Current.Response.Clear();
    HttpContext.Current.Response.Charset = "utf-16";
    HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.GetEncoding("windows-1250");
    HttpContext.Current.Response.AddHeader("content-disposition", string.Format("attachment; filename={0}.xls", fileName));
    HttpContext.Current.Response.ContentType = "application/ms-excel";

    string tab = "";
    foreach (DataColumn dc in DT.Columns)
    {
        HttpContext.Current.Response.Write(tab + dc.ColumnName.Replace("\n", "").Replace("\t", ""));
        tab = "\t";
    }
    HttpContext.Current.Response.Write("\n");

    int i;
    foreach (DataRow dr in DT.Rows)
    {
        tab = "";
        for (i = 0; i < DT.Columns.Count; i++)
        {
            HttpContext.Current.Response.Write(tab + dr[i].ToString().Replace("\n", "").Replace("\t", ""));
            tab = "\t";
        }
        HttpContext.Current.Response.Write("\n");
    }
    HttpContext.Current.Response.End();
}

Aus a Gridview : 

public static void GridviewtoXLS(GridView gv, string fileName)
{
    int DirtyBit = 0;
    int PageSize = 0;
    if (gv.AllowPaging == true)
    {
        DirtyBit = 1;
        PageSize = gv.PageSize;
        gv.AllowPaging = false;
        gv.DataBind();
    }

    HttpContext.Current.Response.Clear();
    HttpContext.Current.Response.Charset = "utf-8";
    HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.GetEncoding("windows-1250");
    HttpContext.Current.Response.AddHeader(
        "content-disposition", string.Format("attachment; filename={0}.xls", fileName));
    HttpContext.Current.Response.ContentType = "application/ms-excel";

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

        //  include the gridline settings
        table.GridLines = gv.GridLines;

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

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

        //  add the footer row to the table
        if (gv.FooterRow != null)
        {
            Utilities.Export.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().Replace("£", ""));
        HttpContext.Current.Response.End();
    }

    if (DirtyBit == 1)
    {
        gv.PageSize = PageSize;
        gv.AllowPaging = true;
        gv.DataBind();
    }
}

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())
        {
            Utilities.Export.PrepareControlForExport(current);
        }
    }
}

Dies ist eine kostenlose Wrapper um SpreadML - es funktioniert super.

http://www.carlosag.net/Tools/ExcelXmlWriter/

Auf der Grundlage die Antworten gegeben, und die Beratung mit Mitarbeitern, scheint es, dass die beste Lösung entweder eine XML-Datei oder HTML-Tabellen zu erzeugen und es nach unten drücken als Anhang. Die eine Änderung von meinen Mitarbeitern empfohlen, dass die Daten (dh die HTML-Tabellen) können direkt an das Response-Objekt geschrieben werden, wodurch die Notwendigkeit entfällt, eine Datei zu schreiben, die aufgrund Berechtigungsprobleme lästig sein können, I / O Streit, und dafür zu sorgen, dass geplante Spülung stattfindet.

Hier ist ein Ausschnitt aus dem Code ... Ich habe dies noch nicht überprüft, und ich habe nicht alle genannt Code geliefert, aber ich denke, es ist die Idee darstellt gut. 

    Dim uiTable As HtmlTable = GetUiTable(groupedSumData)

    Response.Clear()

    Response.ContentType = "application/vnd.ms-excel"
    Response.AddHeader("Content-Disposition", String.Format("inline; filename=OSSummery{0:ddmmssf}.xls", DateTime.Now))

    Dim writer As New System.IO.StringWriter()
    Dim htmlWriter As New HtmlTextWriter(writer)
    uiTable.RenderControl(htmlWriter)
    Response.Write(writer.ToString)

    Response.End()

da Excel versteht man HTML können nur die Daten aus als HTML-Tabelle in eine temporäre Datei schreiben mit einer Erweiterung .xls, die Fileinfo für die Datei erhalten, und blasen sie mit zurück 

Response.Clear();
Response.AddHeader("Content-Disposition", "attachment; filename=" + fi.Name);
Response.AddHeader("Content-Length", fi.Length.ToString());
Response.ContentType = "application/octet-stream";
Response.WriteFile(fi.FullName);
Response.End();

Wenn Sie die temporäre Datei vermeiden wollen, Sie zu einem In-Memory-Stream schreiben konnten und das Bytes schreiben zurück statt Writefile verwenden

, wenn der Content-Length-Header weggelassen Sie nur die HTML direkt zurück schreiben könnte, aber dies möglicherweise nicht richtig in allen Browsern die ganze Zeit arbeiten

Ich persönlich bevorzuge die XML-Methode. Ich werde die Daten aus der Datenbank in einem Datensatz zurückzukehren, um es zu XML-Format speichern, dann schaff' ich eine XSLT-Datei, die eine Transformationsregel enthält, die ein richtiges Dokument formatiert wird, und ein einfache XML-Transformation wird die Arbeit bis beenden. Der beste Teil dieser über Sie Zellen formatieren können, tun die bedingte Formatierung, Setup Kopf- und Fußzeilen und sogar eingestellt Druckbereiche.

Ich habe das ein paar Mal gemacht und jedes Mal, wenn der einfachste Weg, einfach eine CSV-Rückkehr war (Comma Separated Value) Datei. Excel importiert es perfekt, und es ist relativ schnell zu tun.

wir Daten aus einem Datenraster exportieren die ganze Zeit zu übertreffen. Umwandlung in HTML dann in eine Excel-Datei zu schreiben 

Response.ContentType = "application/vnd.ms-excel"
    Response.Charset = ""
    Response.AddHeader("content-disposition", "fileattachment;filename=YOURFILENAME.xls")
    Me.EnableViewState = False
    Dim sw As System.IO.StringWriter = New System.IO.StringWriter
    Dim hw As HtmlTextWriter = New HtmlTextWriter(sw)
    ClearControls(grid)
    grid.RenderControl(hw)
    Response.Write(sw.ToString())
    Response.End()

Die einzige Gotcha mit dieser Methode war, dass viele unserer Netze in ihnen hatten Schaltflächen oder Links, so dass Sie diese brauchen auch: 

'needed to export grid to excel to remove link button control and represent as text
Private Sub ClearControls(ByVal control As Control)
    Dim i As Integer
    For i = control.Controls.Count - 1 To 0 Step -1
        ClearControls(control.Controls(i))
    Next i

    If TypeOf control Is System.Web.UI.WebControls.Image Then
        control.Parent.Controls.Remove(control)
    End If

    If (Not TypeOf control Is TableCell) Then
        If Not (control.GetType().GetProperty("SelectedItem") Is Nothing) Then
            Dim literal As New LiteralControl
            control.Parent.Controls.Add(literal)
            Try
                literal.Text = CStr(control.GetType().GetProperty("SelectedItem").GetValue(control, Nothing))
            Catch
            End Try
            control.Parent.Controls.Remove(control)
        Else
            If Not (control.GetType().GetProperty("Text") Is Nothing) Then
                Dim literal As New LiteralControl
                control.Parent.Controls.Add(literal)
                literal.Text = CStr(control.GetType().GetProperty("Text").GetValue(control, Nothing))
                control.Parent.Controls.Remove(control)
            End If
        End If
    End If
    Return
End Sub

fand ich, dass irgendwo, es funktioniert gut.

Ich empfehle kostenlos Open-Source-Excel Generation libruary welche basiert auf OpenXML

Es hilft mir vor einigen Monaten.

Hier ist ein Bericht, der von einer gespeicherten Prozedur zieht. Die Ergebnisse werden nach Excel exportiert. Es verwendet ADO anstelle von ADO.NET und der Grund, warum ist diese Zeile 

oSheet.Cells(2, 1).copyfromrecordset(rst1)

Es tut die meiste Arbeit und ist in ado.net nicht zur Verfügung. 

‘Calls stored proc in SQL Server 2000 and puts data in Excel and ‘formats it

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim cnn As ADODB.Connection
        cnn = New ADODB.Connection
        cnn.Open("Provider=SQLOLEDB;data source=xxxxxxx;" & _
          "database=xxxxxxxx;Trusted_Connection=yes;")

        Dim cmd As New ADODB.Command


        cmd.ActiveConnection = cnn


        cmd.CommandText = "[sp_TomTepley]"
        cmd.CommandType = ADODB.CommandTypeEnum.adCmdStoredProc
        cmd.CommandTimeout = 0
        cmd.Parameters.Refresh()


        Dim rst1 As ADODB.Recordset
        rst1 = New ADODB.Recordset
        rst1.Open(cmd)

        Dim oXL As New Excel.Application
        Dim oWB As Excel.Workbook
        Dim oSheet As Excel.Worksheet

        'oXL = CreateObject("excel.application")
        oXL.Visible = True
        oWB = oXL.Workbooks.Add
        oSheet = oWB.ActiveSheet

        Dim Column As Integer
        Column = 1

        Dim fld As ADODB.Field
        For Each fld In rst1.Fields

            oXL.Workbooks(1).Worksheets(1).Cells(1, Column).Value = fld.Name
            oXL.Workbooks(1).Worksheets(1).cells(1, Column).Interior.ColorIndex = 15
            Column = Column + 1

        Next fld

        oXL.Workbooks(1).Worksheets(1).name = "Tom Tepley Report"
        oSheet.Cells(2, 1).copyfromrecordset(rst1)
        oXL.Workbooks(1).Worksheets(1).Cells.EntireColumn.AutoFit()


        oXL.Visible = True
        oXL.UserControl = True

        rst1 = Nothing

        cnn.Close()
        Beep()

    End Sub

Wenn Sie füllen ein Gridview mit Daten, die Sie mit dieser Funktion können Sie die HTML-formatierte Daten zu erhalten, aber die den Browser, es ist eine Excel-Datei. 

 Public Sub ExportToExcel(ByVal fileName As String, ByVal gv As GridView)

        HttpContext.Current.Response.Clear()
        HttpContext.Current.Response.AddHeader("content-disposition", String.Format("attachment; filename={0}", fileName))
        HttpContext.Current.Response.ContentType = "application/ms-excel"

        Dim sw As StringWriter = New StringWriter
        Dim htw As HtmlTextWriter = New HtmlTextWriter(sw)
        Dim table As Table = New Table

        table.GridLines = gv.GridLines

        If (Not (gv.HeaderRow) Is Nothing) Then
            PrepareControlForExport(gv.HeaderRow)
            table.Rows.Add(gv.HeaderRow)
        End If

        For Each row As GridViewRow In gv.Rows
            PrepareControlForExport(row)
            table.Rows.Add(row)
        Next

        If (Not (gv.FooterRow) Is Nothing) Then
            PrepareControlForExport(gv.FooterRow)
            table.Rows.Add(gv.FooterRow)
        End If

        table.RenderControl(htw)

        HttpContext.Current.Response.Write(sw.ToString)
        HttpContext.Current.Response.End()

    End Sub


    Private Sub PrepareControlForExport(ByVal control As Control)

        Dim i As Integer = 0

        Do While (i < control.Controls.Count)

            Dim current As Control = control.Controls(i)

            If (TypeOf current Is LinkButton) Then
                control.Controls.Remove(current)
                control.Controls.AddAt(i, New LiteralControl(CType(current, LinkButton).Text))

            ElseIf (TypeOf current Is ImageButton) Then
                control.Controls.Remove(current)
                control.Controls.AddAt(i, New LiteralControl(CType(current, ImageButton).AlternateText))

            ElseIf (TypeOf current Is HyperLink) Then
                control.Controls.Remove(current)
                control.Controls.AddAt(i, New LiteralControl(CType(current, HyperLink).Text))

            ElseIf (TypeOf current Is DropDownList) Then
                control.Controls.Remove(current)
                control.Controls.AddAt(i, New LiteralControl(CType(current, DropDownList).SelectedItem.Text))

            ElseIf (TypeOf current Is CheckBox) Then
                control.Controls.Remove(current)
                control.Controls.AddAt(i, New LiteralControl(CType(current, CheckBox).Checked))

            End If

            If current.HasControls Then
                PrepareControlForExport(current)
            End If

            i = i + 1

        Loop

    End Sub

Just vermeiden COM Interop über Microsoft.Office.Interop Namespace. Es ist so verdammt langsam und unzuverlässig und unbezwingbar. Nicht anwendbar für Masochisten.

Sie können erstellen schön formatierte Excel-Dateien diese Bibliothek nutzen, ganz einfach: http://officehelper.codeplex.com/ Dokumentation .

Microsoft Office muss nicht auf dem Webserver installiert werden!

CSV ist einfachste Weg. Die meiste Zeit ist es in Excel verknüpft. Andernfalls müssen Sie die Automatisierung APIs oder XML-Format verwenden. Die APIs und XML ist nicht so schwer zu bedienen.

Informationen über XML-Generierung für Excel

ich entweder gehen die CSV-Route (wie oben beschrieben) oder häufiger in diesen Tagen, ich verwende Infragistics NetAdvantage die Datei zu erzeugen. (Die sehr große Mehrheit der Zeit, in der Infragistics im Spiel ist, sind wir nur ein bestehende UltraWebGrid Export, der im wesentlichen eine Eins-LOC Lösung, es sei denn zusätzliche Formatierung zwickt benötigt werden. Wir könnten manuell eine Excel / BIFF-Datei erzeugen und, aber es gibt selten eine Notwendigkeit.)

ein Mann, in .net Ich denke, Sie eine Komponente haben könnten, die das tun könnte, aber in klassischen Asp habe ich bereits getan es eine HTML-Tabelle erstellen und den Mime tipe der Seite ändern / msexcel vnd. Ich denke, dass, wenn Sie eine Gridview verwenden und den MIME-Typ ändern vielleicht sollte es funktionieren, weil die gridview eine HTML-Tabelle ist.

Der einzige kugelsichere Weg zur Vermeidung des „Es sieht aus wie diese Zahlen als Text gespeichert sind“ grüne Dreiecke ist das Open XML-Format zu verwenden. Es lohnt sich mit ihm, nur die unvermeidlichen grüne Dreiecke zu vermeiden.

Die beste Methode, die ich für Excel-Berichte gesehen habe, ist die Daten in XML mit einer XML-Erweiterung zu schreiben, und es den Kunden mit dem richtigen Inhaltstyp streamen. (Application / xls)

Dies funktioniert für jeden Bericht, die grundlegende Formatierung erfordert, und ermöglicht es Ihnen, gegen bestehende Tabellen zu vergleichen, indem Textvergleich-Tools.

Unter der Annahme, dies für ein Intranet ist, wo Sie die Berechtigungen und Mandat IE einstellen können, können Sie die Arbeitsmappe Client-Seite mit JScript / VBScript Fahr Excel . Dies gibt Ihnen nativen Excel-Formatierung, ohne den Aufwand zu versuchen, Excel auf dem Server zu automatisieren.

Ich bin mir nicht sicher, ob ich wirklich diesen Ansatz würde empfehlen, mehr außer in ziemlich Nische Szenarien, aber es war ziemlich häufig während der klassischen ASP heydays.

Sie können natürlich immer für eine Komponente von Drittanbietern. Persönlich habe ich eine gute Erfahrung mit Spire.XLS http: //www.e- iceblue.com/xls/xlsintro.htm

Die Komponente ist sehr einfach in der Anwendung zu verwenden: 

        Workbook workbook = new Workbook();

        //Load workbook from disk.
        workbook.LoadFromFile(@"Data\EditSheetSample.xls");
        //Initailize worksheet
        Worksheet sheet = workbook.Worksheets[0];

        //Writes string
        sheet.Range["B1"].Text = "Hello,World!";
        //Writes number
        sheet.Range["B2"].NumberValue = 1234.5678;
        //Writes date
        sheet.Range["B3"].DateTimeValue = System.DateTime.Now;
        //Writes formula
        sheet.Range["B4"].Formula = "=1111*11111";

        workbook.SaveToFile("Sample.xls");

Eines der Probleme, die ich über Mithilfe der Lösungen liefen haben, über dem vorgeschlagen sind ähnlich wie diese Antwort ist, dass wenn Sie den Inhalt herauszudrücken als Anlage (was ich gefunden habe, die sauberste Lösung für nicht-ms-Browsern zu sein), öffnen sie es dann in Excel 2000-2003, ist seine Art eine „Excel Web-Seite“ und nicht ein native Excel-Dokument.

Dann müssen Sie den Benutzern erklären, wie „als Typ Speichern“ verwenden in Excel es in ein Excel-Dokument zu konvertieren. Dies ist ein Schmerz, wenn die Benutzer dieses Dokument bearbeiten müssen und dann neu laden Sie es auf Ihrer Website.

Meine Empfehlung ist, CSV zu verwenden. Es ist einfach und wenn Benutzer es tun öffnen in Excel, Excel zumindest fordert sie es in ihrem nativen Format zu speichern.

Ich würde nur eine CSV-Datei erstellen, die auf der Grundlage der Daten, weil ich als der sauberste sehen, dass und Excel für sie eine gute Unterstützung hat. Aber wenn Sie ein flexibleres Format benötigen, ich bin sicher, es gibt einige 3rd-Party-Tools zum Erzeugen von echten Excel-Dateien.

Hier ist eine Lösung, die Ströme der Datentabelle aus als CSV. Schnell, sauber und einfach, und es Griffe Kommas in der Eingabe. 

public static void ExportToExcel(DataTable data, HttpResponse response, string fileName)
{
    response.Charset = "utf-8";
    response.ContentEncoding = System.Text.Encoding.GetEncoding("windows-1250");
    response.Cache.SetCacheability(HttpCacheability.NoCache);
    response.ContentType = "text/csv";
    response.AddHeader("Content-Disposition", "attachment; filename=" + fileName);

    for (int i = 0; i < data.Columns.Count; i++)
    {
       response.Write(data.Columns[i].ColumnName);
       response.Write(i == data.Columns.Count - 1 ? "\n" : ",");
    }        
    foreach (DataRow row in data.Rows)
    {
        for (int i = 0; i < data.Columns.Count; i++)
        {
            response.Write(String.Format("\"{0}\"", row[i].ToString()));
            response.Write(i == data.Columns.Count - 1 ? "\n" : ",");
        }
    }

    response.End();
}

erstellt nur eine Funktion von einem Web-Formular C # exportieren zu übertreffen hoffen, dass es andere hilft 

    public void ExportFileFromSPData(string filename, DataTable dt)
    {
        HttpResponse response = HttpContext.Current.Response;

        //clean up the response.object
        response.Clear();
        response.Buffer = true;
        response.Charset = "";

        // set the response mime type for html so you can see what are you printing 
        //response.ContentType = "text/html";
        //response.AddHeader("Content-Disposition", "attachment;filename=test.html");

        // set the response mime type for excel
        response.ContentType = "application/vnd.ms-excel";
        response.AddHeader("Content-Disposition", "attachment;filename=\"" + filename + "\"");
        response.ContentEncoding = System.Text.Encoding.UTF8;
        response.BinaryWrite(System.Text.Encoding.UTF8.GetPreamble());

        //style to format numbers to string
        string style = @"<style> .text { mso-number-format:\@; } </style>";
        response.Write(style);

        // create a string writer
        using (StringWriter sw = new StringWriter())
        {
            using (HtmlTextWriter htw = new HtmlTextWriter(sw))
            {
                // instantiate a datagrid
                GridView dg = new GridView();
                dg.DataSource = dt;
                dg.DataBind();

                foreach (GridViewRow datarow in dg.Rows)
                {
                    //format specific cell to be text 
                    //to avoid 1.232323+E29 to get 1232312312312312124124
                    datarow.Cells[0].Attributes.Add("class", "text");
                }

                dg.RenderControl(htw);
                response.Write(sw.ToString());
                response.End();
            }
        }
     }

Wenn Sie Excel verwenden statt einer CSV-Datei haben, müssen Sie OLE-Automatisierung auf einer Excel-Instanz einen der Server verwenden. Der einfachste Weg, dies zu tun, ist eine Template-Datei haben, und es programmatisch mit den Daten zu füllen. Sie speichern Sie es auf eine andere Datei.

Tipp:

  • Sie es nicht interaktiv tun. Haben Sie den Benutzer Kick-off-Prozess und dann schreiben Sie eine Seite mit dem Link auf die Datei. Dies mildert potenzielle Performance-Probleme, während die Kalkulationstabelle generiert wird.
  • Verwenden Sie die Vorlage, wie ich vorher beschrieben. Das macht es leichter, ihn zu ändern.
  • Stellen Sie sicher, dass Excel festgelegt ist nicht Dialogen auftauchen. Auf einem Webserver wird dies die gesamte Excel-Instanz hängen.
  • Halten Sie die Excel-Instanz auf einem separaten Server, vorzugsweise hinter einer Firewall, so dass es nicht als potenzielles Sicherheitsloch ausgesetzt.
  • ein Auge auf die Ressourcennutzung halten. Erzeugen eines spreadhseet über die OLE-Automation-Schnittstelle (die PIAs sind nur über diese Beilagscheiben) ist ein ziemlich Schwergewicht Prozess. Wenn Sie dies zu hohen Datenmengen skalieren müssen Sie möglicherweise etwas klug sein, mit Ihrer Architektur.

Einige der ‚Verwendung Mime-Typen zeichnen sich in der Öffnung HTML-Tabelle, Trick‘ Ansätze funktionieren würden, wenn Sie ein bisschen einfach zu sein nicht das Format der Datei kümmern. Diese Ansätze fob auch die CPU schwere Arbeit auf den Client aus. Wenn Sie die Fein graned Kontrolle über das Format der Tabelle wollen, werden Sie wahrscheinlich selbst verwenden Excel um die Datei zu erzeugen, wie oben beschrieben.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top