Wie erstelle ich eine Excel (.xls und .xlsx) Datei in C #, ohne Microsoft Office zu installieren? [geschlossen]
https://stackoverflow.com/questions/151005
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wie kann ich eine Excel-Tabelle mit C # erstellen, ohne Excel erfordern auf dem Rechner installiert werden, die den Code ausgeführt wird?
Lösung
Sie können eine Bibliothek verwenden genannt ExcelLibrary. Es ist eine kostenlose Open-Source-Bibliothek veröffentlicht auf Google Code:
Das sieht eine Portierung des PHP ExcelWriter sein, die Sie oben erwähnt. Es wird noch nicht auf das neue XLSX-Format schreiben, aber sie arbeiten auf Hinzufügen, dass die Funktionalität in.
Es ist sehr einfach, klein und einfach zu bedienen. Plus hat es eine DataSetHelper, die Sie leicht verwenden Datasets und Datentabellen können auf mit Excel-Daten zu arbeiten.
ExcelLibrary scheint nach wie vor nur für das ältere Excel-Format (.xls-Dateien) zu arbeiten, aber sein kann für neuere 2007/2010 Formate Unterstützung in der Zukunft hinzuzufügen.
Sie können auch verwenden EPPlus , die nur für Excel 2007/2010-Format-Dateien (XLSX-Dateien funktioniert ). Es gibt auch NPOI , die beide Werke mit.
Es gibt einige bekannte Fehler mit jeder Bibliothek wie in den Kommentaren zur Kenntnis genommen. Insgesamt scheint EPPlus die beste Wahl zu sein, wie die Zeit vergeht. Es scheint, als auch aktiver aktualisiert und dokumentiert werden.
Auch wie bereits erwähnt, durch @ АртёмЦарионов unten, hat EPPlus Unterstützung für Pivot-Tabellen und ExcelLibrary können eine gewisse Unterstützung haben ( Pivot-Tabelle Ausgabe in ExcelLibrary )
Hier sind ein paar Links zum schnellen Nachschlagen:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Apache License
Hier einige Beispiel-Code für ExcelLibrary:
Hier ist ein Beispiel Daten aus einer Datenbank und die Schaffung einer Arbeitsmappe von mitnimmt. Beachten Sie, dass die ExcelLibrary Code die einzige Zeile am unteren Rand 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);
die Excel-Datei zu erstellen ist so einfach wie das. Sie können auch Excel-Dateien manuell erstellen, aber die obige Funktionalität ist es, was mich wirklich beeindruckt.
Andere Tipps
Wenn Sie zufrieden mit dem xlsx-Format sind, versuchen mein GitHub Projekt, EPPlus . Es begann mit der Quelle von ExcelPackage, aber heute ist es ein insgesamt Rewrite. Es unterstützt Bereiche, Zell Styling, Grafiken, Formen, Bilder, benannte Bereiche, Autofilter und viele andere Sachen.
ich mit Erfolg verwendet haben die folgenden Open Source-Projekte:
-
ExcelPackage für OOXML-Formate (Office 2007)
-
NPOI für XLS-Format (Office 2003). auch NPOI 2.0 (Beta) unterstützt XLSX.
Werfen Sie einen Blick auf meinen Blog-Posts:
Und was ist Open XML SDK 2.0 für Microsoft Office verwenden?
Ein paar Vorteile:
- Benötigt keine Installation von Office
- Hergestellt von Microsoft = anständige MSDN-Dokumentation
- Nur ein .NET-DLL in einem Projekt verwenden
- SDK kommt mit vielen Werkzeugen wie diff, Validator, etc
Links:
- herunterladen SDK
- Haupt MSDN Landing
- "Wie kann ich ..." starter Seite
- blogs.MSDN brian_jones kündigt SDK
- blogs.MSDN brian_jones beschreibt SDK große Dateien Handhabung ohne (im Gegensatz zu DOM-Methode) abstürzt
Sie können OLEDB verwenden, um Excel-Dateien zu erstellen und bearbeiten. Sehen Sie sich diese: 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:
Die kommerzielle Lösung, SpreadsheetGear for .NET wird es tun.
Sie sehen Live ASP.NET (C # und VB) Proben hier und downloaden ein Testversion hier .
Disclaimer: Ich besitze SpreadsheetGear LLC
Ein paar Optionen, die ich verwendet habe:
Wenn XLSX ist ein Muss: ExcelPackage ist ein guter Anfang, aber abgestorben, wenn der Entwickler aufhören, daran zu arbeiten. ExML nahm von dort nach oben und noch ein paar Features. ExML ist keine schlechte Option, verwende ich es noch in ein paar Produktions Websites .
Für alle meine neuen Projekte, aber ich bin mit NPOI , die .NET-Port Apache POI . NPOI 2.0 (Alpha) auch XLSX unterstützt.
Eine extrem leichte Option kann HTML-Tabellen verwenden. Erstellen Sie einfach den Kopf, Körper und Tabellen-Tags in einer Datei und als Datei mit einer Erweiterung von .xls speichern. Es gibt Microsoft spezifische Attribute, die Sie die Ausgabe, um Stil verwenden können, einschließlich Formeln.
Ich weiß, dass Sie dies nicht in einer Web-Anwendung werden Codierung kann, aber hier ist ein Beispiel der Zusammensetzung von einer Excel-Datei über eine HTML-Tabelle. Diese Technik verwendet werden könnte, wenn Sie eine Konsole-Anwendung, Desktop-App wurden Codierung oder Service.
Sie können mit ExcelXmlWriter .
Es funktioniert gut.
Wenn Sie erstellen Excel 2007/2010 Dateien geben diesem Open-Source-Projekt einen Versuch: https: // GitHub. com / closedxml / closedxml
Es bietet eine objektorientierte Art und Weise die Dateien (ähnlich zu manipulieren VBA), ohne den Ärger von XML-Dokumenten zu tun. Es kann benutzt werden von jeder .NET-Sprache wie C # und Visual Basic (VB).
ClosedXML ermöglicht es Ihnen, Excel 2007/2010 Dateien ohne Excel zu erstellen Anwendung. Das typische Beispiel ist die Erstellung von Excel-Berichten auf einem Web Server:
var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add("Sample Sheet"); worksheet.Cell("A1").Value = "Hello World!"; workbook.SaveAs("HelloWorld.xlsx");
Sie wollen tatsächlich könnte die Interop-Klassen überprüfen . Sie sagen, keine OLE (die dies nicht), aber die Interop-Klassen sind sehr einfach zu bedienen.
Sie könnten beeindruckt, wenn man sich nicht versucht hat.
Bitte seien Sie gewarnt von Microsofts Haltung auf diese:
Microsoft derzeit nicht empfehlen, und nicht unterstützt, Automatisierung von Microsoft Office-Anwendungen von jedem unbeaufsichtigt, nicht-interaktive Client-Anwendung oder eine Komponente (einschließlich ASP, ASP.NET, DCOM und NT Services), da Office instabil aufweisen kann Verhalten und / oder Deadlock, wenn Office in dieser Umgebung ausgeführt werden.
Hier ist eine völlig freie C # Bibliothek, die Sie von einem DataSet, DataTable oder List<> in eine echte Excel 2007 XLSX-Datei exportieren kann, die OpenXML-Bibliotheken:
http://mikesknowledgebase.com/pages/CSharp/ExportToExcel.htm
Die vollständige Quellcode ist vorgesehen - kostenfrei - zusammen mit Anweisungen und eine Demo-Anwendung
.diese Klasse zu Ihrer Anwendung hinzugefügt haben, können Sie Ihr DataSet in Excel exportieren in nur einer Codezeile:
CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");
Es ist nicht viel einfacher als die ...
Und es ist nicht einmal erforderlich, Excel auf Ihrem Server vorhanden sein.
Sie könnten, Ihre Dateien zu erstellen, die XML-Kalkulationstabelle 2003 Format. Dies ist ein einfaches XML-Format ein gut dokumentiert Schema .
Sie können einen Blick auf GemBox.Spreadsheet nehmen wollen.
Sie haben eine kostenlose Version mit allen Features, aber zu 150 Zeilen pro Blatt und 5 Blättern pro Arbeitsmappe begrenzt, wenn diese innerhalb Ihrer Bedürfnisse fällt.
Ich habe Notwendigkeit nicht hatte es selbst noch zu verwenden, aber sieht interessant.
Syncfusion Wesentliche XlsIO können dies tun. Es hat keine Abhängigkeit von Microsoft Office und hat auch spezifische Unterstützung für verschiedene Plattformen.
- ASP.NET
- ASP.NET MVC
- UWP
- Xamarin
- WPF und Windows Forms
- Windows Service und Batch-basierte Operationen
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 ganze Reihe von Kontrollen ist kostenlos durch das Community Lizenz Programm zur Verfügung, wenn Sie qualifizieren ( weniger als 1 Mio. USD bei den Einnahmen). Hinweis:. Ich arbeite für Syncfusion
Nun,
Sie können auch eine dritte Partei Bibliothek wie Aspose .
Diese Bibliothek hat den Vorteil, dass es nicht Excel erfordert auf Ihrem Rechner installiert werden, die in Ihrem Fall wäre ideal.
Die verschiedenen Office 2003 XML-Bibliotheken verfügbare Arbeit ziemlich gut für kleinere Excel-Dateien. Allerdings finde ich die schiere Größe einer großen Arbeitsmappe im XML-Format gespeichert ein Problem zu sein. Zum Beispiel wäre 40MB in der neuen (und zwar dichter gepackt) XLSX-Format eine Arbeitsmappe ich damit arbeiten wird eine 360MB XML-Datei.
Was meine Forschung mich getroffen hat, gibt es zwei kommerzielle Pakete, die Ausgabe zu den älteren binären Dateiformaten ermöglichen. Sie sind:
Weder sind billig (500USD und 800USD jeweils glaube ich). aber beide arbeiten unabhängig von Excel selbst.
Was würde ich gespannt sein, ist das Excel-Ausgabe-Modul für die Gleichen von OpenOffice.org. Ich frage mich, ob sie von Java nach .NET portiert werden.
OpenXML ist auch eine gute Alternative, die MS Excel auf Server.Verfahren Open XML SDK 2.0 von Microsoft vereinfacht die Aufgabe der Manipulation von Open XML-Pakete und die zugrunde liegenden Open XML Schema-Elemente innerhalb eines Pakets installiert hilft zu vermeiden. Die Open XML Application Programming Interface (API) kapselt viele gemeinsame Aufgaben, die Entwickler auf Open XML-Pakete durchführen.
Check this out OpenXML: Alternative, vermeiden hilft auf Server MS Excel Installation
Ich bin damit einverstanden XML-Tabellen über das Generieren, hier ist ein Beispiel, wie man es tun für C # 3 (alle Blogs nur um es in VB 9: P) http://www.aaron-powell.com/linq-to-xml-to-excel
Ich habe gerade vor kurzem verwendet FlexCel.NET und fand es eine ausgezeichnete Bibliothek sein! Ich sage nicht, dass über zu viele Software-Produkte. Kein Punkt in der gesamten Verkaufsmasche hier geben, können Sie alle Funktionen auf ihrer Website lesen.
Es ist ein kommerzielles Produkt, aber Sie bekommen die volle Quelle, wenn Sie es kaufen. Also nehme ich an Sie es in Ihrer Assembly kompilieren können, wenn Sie wirklich wollten. Ansonsten ist es nur eine zusätzliche Montage zu xcopy -. Keine Konfiguration oder Installation oder so etwas
Ich glaube nicht, dass Sie eine Möglichkeit, dies ohne Bibliotheken von Drittanbietern zu tun finden als .NET-Framework, offensichtlich hat nicht die Unterstützung für sie gebaut und OLE-Automatisierung ist nur eine ganze Welt der Schmerzen.
Ich will nur einen weiteren Hinweis auf einen Dritten Lösung hinzuzufügen, die Ihre Frage direkt adressiert: http://www.officewriter.com
(Disclaimer: Ich arbeite für SoftArtisans, die Firma, die Office macht)
Ich habe einen einfachen Code geschrieben Datensatz exportieren, indem Sie mit System.IO.StreamWriter ohne Verwendung von Excel-Objekt zu übertreffen.
Im Folgenden finden Sie den Code, der alle Tabellen aus Dataset lesen und schreiben sie auf Blätter eins nach dem anderen. Ich habe Hilfe von diesem Artikel .
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();
}
Hier ist ein Weg, um es mit LINQ to XML zu tun, komplett mit Beispielcode:
schnell Import und Export von Excel-Daten mit LINQ to XML
Es ist ein wenig kompliziert, da Sie Namespaces importieren müssen und so weiter, aber es können Sie alle externen Abhängigkeiten vermeiden.
(Auch, natürlich, es ist VB .NET, C # nicht, aber Sie können die VB .NET Sachen in seinem eigenen Projekt immer isolieren XML-Literale zu verwenden, und alles anderes in C # tun.)
Einige 3rd-Party-Komponente Anbietern wie Infragistics oder Syncfusion bieten sehr gute Excel-Export-Funktionen, die nicht installiert Microsoft Excel benötigt werden.
Da diese Anbieter auch erweitern UI Grid-Komponenten bieten, sind diese Komponenten besonders praktisch, wenn Sie den Stil und das Layout einer Excel exportieren wollen den aktuellen Zustand eines Gitters in der Benutzeroberfläche Ihrer Anwendung zu simulieren.
Wenn Ihr den Export bestimmt ist auf den Daten mit dem Schwerpunkt Server-Seite ausgeführt werden exportiert werden und ohne Verbindung zum UI, dann würde ich für einen der freien Open-Source-Optionen gehen (z ExcelLibrary).
ich vorher mit Projekten beteiligt, die versuchten, serverseitige Automatisierung auf dem Microsoft Office Suite. Aufgrund dieser Erfahrung würde ich gegen diesen Ansatz sehr 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 ist diese Lösung Ihre Rasteransicht Ihre Excel-Export-Datei, es könnte Ihnen helfen,
Sie erstellen können schön Excel-Dateien mit dieser Bibliothek formatiert:
http://officehelper.codeplex.com/documentation
Siehe unten Beispiel:
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");
}
Dabei gilt Probe wie folgt 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};
}
}
Die einfachste und schnellste Weg, um eine Excel-Datei von C # zu erstellen, ist das Open XML-Productivity-Tool zu verwenden. Der Open XML Productivity-Tool kommt mit dem Open XML SDK-Installation. Das Werkzeug Reverse Engineers beliebige Excel C # -Code-Datei in. Das C # -Code kann dann verwendet werden, die Datei neu zu erzeugen.
Eine Übersicht über den Prozess eingebunden ist:
- Installieren Sie das Open XML SDK mit dem Werkzeug.
- Erstellen Sie eine Excel-Datei mit dem neuesten Excel-Client mit gewünschtem Look mit. Nennen Sie es
DesiredLook.xlsx. - Mit dem Werkzeug geöffnet
DesiredLook.xlsxund klicken Sie auf den Kodex Reflect-Schaltfläche oben.
- Der C # Code für Ihre Datei wird im rechten Bereich des Werkzeugs erzeugt werden. Fügen Sie diese auf Ihre C # Lösung und erzeugen Dateien mit diesem gewünschten Look.
Als Bonus funktioniert diese Methode für alle Word und Powerpoint-Dateien. Als C # -Entwickler, werden Sie dann den Code Änderungen an Ihre Bedürfnisse anzupassen.
ich entwickelt habe, ein einfache WPF-Anwendung auf Github , die unter Windows für diesen Zweck ausgeführt wird. Es ist ein Platzhalter Klasse namens GeneratedClass, wo Sie den generierten Code einfügen können. Wenn Sie wieder eine Version der Datei gehen, wird es eine Excel-Datei wie folgt erzeugen:
Einige nützliche Excel-Automatisierung in C #, u aus dem folgenden Link finden.
http://csharp.net-informations.com/excel/ csharp-excel-tutorial.htm
bolton.
Sehen Sie in Proben, wie Excel-Dateien erstellen.
Es gibt Beispiele in C # und VB.NET
Es verwaltet XSL XSLX und CSV Excel-Dateien.
