Comment puis-je créer un fichier Excel (.XLS et .XLSX) le fichier en C# sans l'installation de Microsoft Office?

Si vous êtes heureux avec le format xlsx, essayer de mon projet GitHub, EPPlus. Cela a commencé avec la source de ExcelPackage, mais aujourd'hui, c'est une réécriture totale.
Il prend en charge les plages, la cellule de style, des graphiques, des formes, des images, des plages nommées, filtre automatique et un tas d'autres choses.

Et ce sur l'utilisation de Open XML SDK 2.0 pour Microsoft Office?

Quelques avantages:

• Ne nécessite pas Office installé
• Faite par Microsoft = décent documentation MSDN
• Un seul .Net dll à utiliser dans le projet
• SDK est livré avec de nombreux outils comme diff, validateur, etc

Liens:

• Télécharger SDK
• Principal MSDN à l'Atterrissage
• "Comment Faire pour..." page de démarrage
• blogs.MSDN brian_jones annonce SDK
• blogs.MSDN brian_jones décrivant SDK le traitement de gros fichiers sans s'écraser (contrairement à la méthode DOM)

La solution commerciale, SpreadsheetGear pour .NET va le faire.

Vous pouvez voir en direct ASP.NET (C# et VB) des échantillons ici et télécharger une version d'évaluation ici.

Avertissement: je possède SpreadsheetGear LLC

Extrêmement léger option peut être d'utiliser des tables HTML. Il suffit de créer une tête, un corps, et les balises de tableau dans un fichier et l'enregistrer comme un fichier avec une .extension xls. Il y a Microsoft attributs spécifiques que vous pouvez utiliser pour le style de la sortie, y compris les formules.

Je me rends compte que vous ne pouvez pas être ce codage dans une application web, mais voici un exemple de la composition d'un fichier Excel via un tableau HTML. Cette technique pourrait être utilisée si vous avez été codage d'une application console, application de bureau ou de service.

Si vous êtes à la création de fichiers Excel 2007/2010 donner à ce projet open source d'essayer: https://github.com/closedxml/closedxml

Il fournit un objet orienté de façon à manipuler les fichiers (similaire à
VBA) sans traiter avec les tracas de Documents XML. Il peut être utilisé
par tout .NET des langages comme le C# et Visual Basic (VB).

ClosedXML vous permet de créer des fichiers Excel 2007/2010 sans Excel
application. L'exemple typique est celui de la création de rapports Excel sur un site web
serveur:

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

Ici est totalement gratuit C# de la bibliothèque, qui vous permet d'exporter à partir d'un DataSet, DataTable ou List<> en un véritable Excel 2007 .fichier xlsx, à l'aide de l'OpenXML bibliothèques:

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

L'intégralité du code source est fourni gratuitement avec les instructions, et une démo de l'application.

Après l'ajout de cette classe à votre application, vous pouvez exporter vos données vers Excel en une seule ligne de code:

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

Il ne va pas beaucoup plus simple que ça...

Et il n'a même pas besoin d'Excel pour être présent sur votre serveur.

Vous pouvez prendre un coup d'oeil à GemBox.Feuille de calcul.

Ils ont une version gratuite avec toute les fonctionnalités mais limitée à 150 lignes par feuille et 5 feuilles par classeur, si cela relève de vos besoins.

Je n'ai pas eu besoin de l'utiliser moi-même encore, mais ne semblent intéressants.

Bien,

vous pouvez également utiliser une bibliothèque tierce comme Aspose.

Cette bibliothèque, qui a l'avantage de ne pas nécessiter Excel doit être installé sur votre machine, ce qui serait l'idéal dans votre cas.

Les différents XML Office 2003 bibliothèques disponibles fonctionner assez bien pour les petits fichiers excel. Cependant, je trouve la taille d'un grand classeur enregistré au format XML à être un problème. Par exemple, un classeur, je travaille à ce que serait 40 mo d'espace dans la nouvelle (et, certes, plus serrés) format XLSX devient un 360MB fichier XML.

En ce qui concerne ma recherche m'a pris, il y a deux packages qui permettent de sortie pour les plus âgés les formats de fichiers binaires. Ils sont:

• Gembox
• ComponentOne Excel

Ne sont ni bon marché (500USD et 800USD respectivement, je pense). mais à la fois le travail indépendant de Excel lui-même.

Ce que je serais curieux de savoir le Excel module de sortie pour les goûts de OpenOffice.org. Je me demande si ils peuvent être portés de Java pour .Net.

J'ai tout récemment utilisé FlexCel.NET et l'a trouvé pour être une excellente bibliothèque! Je ne dis pas que les propos trop grand nombre de produits logiciels. Aucun point en donnant à l'ensemble de l'argumentaire de vente ici, vous pouvez lire toutes les fonctionnalités sur leur site web.

C'est un produit commercial, mais vous obtenez le plein de la source si vous l'achetez. Donc, je suppose que vous pourriez compiler dans votre assemblée, si tu le voulais vraiment. Sinon, c'est juste un assemblage de xcopy - pas de configuration ou l'installation, ou quelque chose comme ça.

Je ne pense pas que vous trouverez de toute façon de le faire sans tiers des bibliothèques .NET framework, évidemment, n'a pas intégré dans le support et de OLE Automation est juste tout un monde de douleur.

J'ai écrit un code simple pour exporter l'ensemble de données d'excel sans l'aide d'excel objet à l'aide de Système.IO.StreamWriter.

Ci-dessous est le code qui permettra de lire toutes les tables des bases de données et de les écrire sur les feuilles une par une. J'ai pris l'aide de cet article.

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

Voici une façon de le faire avec LINQ to XML, complète avec des exemples de code:

Rapidement Importer et d'Exporter des Données Excel avec LINQ to XML

C'est un peu complexe, puisque vous devez importer les espaces de noms et ainsi de suite, mais permet d'éviter toute dépendance externe.

(Aussi, bien sûr, c'est VB .NET, C#, mais vous pouvez toujours isoler le VB .NET des trucs dans son propre projet pour utiliser les Littéraux XML, et faire tout le reste en C#.)

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

Salut cette solution est d'exporter votre affichage de la grille de votre fichier excel, il peut vous aider

Le plus simple et le plus rapide de créer un fichier Excel à partir de C# est l'utilisation de l'Open XML Outil de Productivité. L'Open XML de la Productivité de l'Outil est livré avec le SDK Open XML d'installation. L'outil inverse ingénieurs importe quel fichier Excel dans le code C#. Le code C# peut ensuite être utilisé pour re-générer le fichier.

Une vue d'ensemble du processus est:

1. Installer le SDK Open XML avec l'outil.
2. Créer un fichier Excel à l'aide de la dernière Excel client avec le look désiré. Nom il DesiredLook.xlsx.
3. Avec l'outil open DesiredLook.xlsx et cliquez sur le Refléter Code bouton en haut.
   
4. Le code C# pour votre fichier sera généré dans le volet de droite de l'outil. Ajouter à votre solution C# et de générer des fichiers avec le style désiré.

Comme un bonus, cette méthode fonctionne pour tous les fichiers Word et PowerPoint. Tant que développeur C#, vous pourrez ensuite modifier le code pour l'adapter à vos besoins.

J'ai développé une simple d'application WPF sur github qui sera exécuté sur Windows pour cela. Il y a un espace réservé à la classe appelée GeneratedClass où vous pouvez coller le code généré. Si vous revenir à la version du fichier, il va générer un fichier excel comme ceci:

Coup d'œil aux exemples comment créer des fichiers Excel.

Il y a des exemples dans C# et VB.NET

Il gère XSL XSLX et CSV fichiers Excel.

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

La Java open source de la solution est Apache POI. Peut-être il ya un moyen de l'installation de l'interopérabilité ici, mais je ne sais pas assez sur Java pour répondre à ça.

Quand j'ai exploré ce problème, j'ai fini par utiliser les assemblys Interop.

J'ai aussi voter pour GemBox.Feuille de calcul.

Est très facile et rapide à utiliser, avec des tonnes d'exemples sur leur site.

Pris mes tâches de reporting sur un tout nouveau niveau de vitesse d'exécution.

Recherchez ExtremeML. C'est assez cool de la bibliothèque qui vous permet d'utiliser le format OpenXML pour générer des fichiers OpenXML.

C'est aussi un projet OpenSource.

http://www.extrememl.com/

Si vous faites des données de la table ou de la datagridview à partir du code, vous pouvez enregistrer toutes les données à l'aide de cette méthode simple.cette méthode n'est pas recommandée, mais son travail à 100%, même si vous n'êtes pas installer MS Excel dans votre ordinateur.

try
{
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.Filter = "Excel Documents (*.xls)|*.xls";
saveFileDialog1.FileName = "Employee Details.xls";
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
string fname = saveFileDialog1.FileName;
StreamWriter wr = new StreamWriter(fname);
for (int i = 0; i <DataTable.Columns.Count; i++)
{
wr.Write(DataTable.Columns[i].ToString().ToUpper() + "\t");
}
wr.WriteLine();
//write rows to excel file
for (int i = 0; i < (DataTable.Rows.Count); i++)
{
for (int j = 0; j < DataTable.Columns.Count; j++)
{
if (DataTable.Rows[i][j] != null)
{
wr.Write(Convert.ToString(getallData.Rows[i][j]) + "\t");
}
else
{
wr.Write("\t");
}
}
//go to next line
wr.WriteLine();
}
//close file
wr.Close();
}
}
catch (Exception)
{
MessageBox.Show("Error Create Excel Sheet!");
}

Pour enregistrer xls en xlsx, nous avons juste besoin de faire appel SaveAs méthode de Microsoft.Office.Interop.Excel de la bibliothèque. Cette méthode prendra environ 16 paramètres et l'un d'eux est le format de fichier ainsi.

De document de Microsoft: Ici
Méthode SaveAs Arguments

L'objet, nous devons passer, c'est comme

wb.SaveAs(filename, 51, System.Reflection.Missing.Value,
System.Reflection.Missing.Value, false, false, 1,1, true, 
System.Reflection.Missing.Value, System.Reflection.Missing.Value, System.Reflection.Missing.Value)

Ici, 51, a est valeur d'énumération pour XLSX

Pour SaveAs dans différents formats de fichier, vous pouvez consulter la xlFileFormat

Je suis à l'aide de code suivant pour créer de fichier excel 2007 qui créer le fichier et écrire dans ce fichier, mais quand j'ouvre le fichier mais il me donner l'erreur que
exel ne peut pas ouvrir le fichier bcz fichier peut être coruupted ou l'extension du fichier n'est pas compatible.
mais si j'ai utilisé .xls pour déposer travail des amendes

for (int i = 0; i < TotalFile; i++)
{
Contact.Clear();
if (innerloop == SplitSize)
{
for (int j = 0; j < SplitSize; j++)
{
string strContact = DSt.Tables[0].Rows[i * SplitSize + j][0].ToString();
Contact.Add(strContact);
}
string strExcel = strFileName + "_" + i.ToString() + ".xlsx";
File.WriteAllLines(strExcel, Contact.ToArray());
}
}

également consulter le lien

http://dotnet-magic.blogspot.in/2011/10/createformat-excel-file-from-cnet.html