Comment créer un fichier Excel (.XLS et .XLSX) en C # sans installer Ms Office?
Comment créer une feuille de calcul Excel avec C # sans avoir besoin d'installer Excel sur la machine exécutant le code?
Vous pouvez utiliser une bibliothèque appelée ExcelLibrary. C'est une librairie gratuite et open source publiée sur Google Code:
Cela semble être un portage de PHP ExcelWriter que vous avez mentionné ci-dessus. Il n'écrira pas encore le nouveau format .xlsx, mais ils travaillent à l'ajout de cette fonctionnalité dans.
C'est très simple, petit et facile à utiliser. De plus, il dispose d'un DataSetHelper qui vous permet d'utiliser DataSets et DataTables pour travailler facilement avec les données Excel.
ExcelLibrary ne semble toujours fonctionner que pour l'ancien format Excel (fichiers .xls), mais pourrait éventuellement prendre en charge d'autres formats 2007/2010 plus récents.
Vous pouvez également utiliser EPPlus , qui ne fonctionne que pour les fichiers au format Excel 2007/2010 (fichiers .xlsx). Il y a aussi NPOI qui fonctionne avec les deux.
Il existe quelques bugs connus avec chaque bibliothèque, comme indiqué dans les commentaires. Au total, EPPlus semble être le meilleur choix avec le temps. Il semble également être plus activement mis à jour et documenté.
De plus, comme l'a noté @ АртёмЦарионов ci-dessous, EPPlus prend en charge les tableaux croisés dynamiques et ExcelLibrary peut avoir un support ( Problème de tableau croisé dynamique dans ExcelLibrary )
Voici quelques liens pour une référence rapide:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Licence publique générale réduite (LGPL)
NPOI - Licence Apache
Voici quelques exemples de code pour ExcelLibrary:
Voici un exemple prenant des données d'une base de données et en créant un classeur. Notez que le code ExcelLibrary est la seule ligne en bas:
//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);
La création du fichier Excel est aussi simple que cela. Vous pouvez également créer manuellement des fichiers Excel, mais la fonctionnalité ci-dessus est ce qui m'a vraiment impressionné.
Si vous êtes satisfait du format xlsx, essayez mon codeplex Projet GitHub. EPPlus . A commencé avec le source de ExcelPackage, mais c’est aujourd’hui une réécriture totale… .. Prend en charge les plages, le style des cellules, les graphiques, les formes, les images, les plages de noms, le filtre automatique et bien d’autres choses.
J'ai utilisé avec succès les projets open source suivants:
ExcelPackage pour les formats OOXML (Office 2007)
NPOI pour le format .XLS (Office 2003). NPOI 2.0 (Beta) prend également en charge XLSX.
Jetez un coup d'œil à mes articles de blog:
Et qu’en est-il de l’utilisation de Open XML SDK 2.0 pour Microsoft Office?
Quelques avantages:
- Ne nécessite pas Office installé
- Fabriqué par Microsoft = documentation MSDN décente
- Une seule DLL .Net à utiliser dans le projet
- Le SDK est livré avec de nombreux outils comme diff, validateur, etc.
Liens:
Vous pouvez utiliser OLEDB pour créer et manipuler des fichiers Excel. Cochez cette case: Lecture et écriture d’Excel avec OLEDB .
Exemple typique:
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 - Quelques autres liens:
La solution commerciale, SpreadsheetGear for .NET le fera.
Vous pouvez voir des exemples ASP.NET (C # et VB) en direct ici et télécharger une version d’évaluation ici .
Disclaimer: Je possède SpreadsheetGear LLC
Quelques options que j'ai utilisées:
Si XLSX est un must: ExcelPackage est un bon début, mais il est mort quand le développeur a cessé de travailler dessus. ExML a ramassé à partir de là et a ajouté quelques fonctionnalités. ExML n’est pas une mauvaise option, je l’utilise toujours dans quelques sites de production.
Pour tous mes nouveaux projets, cependant, j'utilise NPOI , le port .NET de Apache POI . NPOI 2.0 (Alpha) prend également en charge XLSX.
Une option extrêmement légère peut consister à utiliser des tableaux HTML. Créez simplement des balises head, body et table dans un fichier et enregistrez-le en tant que fichier avec une extension .xls. Il existe des attributs spécifiques à Microsoft que vous pouvez utiliser pour styliser la sortie, y compris des formules.
Je réalise que vous ne codez peut-être pas cela dans une application web, mais voici un exemple de la composition d'un fichier Excel via un tableau HTML. Cette technique peut être utilisée si vous codez une application de console, une application de bureau ou un service.
Vous pouvez utiliser ExcelXmlWriter .
Ça fonctionne bien.
Vous voudrez peut-être consulter les classes interop . Vous dites non OLE (ce qui n'est pas le cas), mais les classes d'interopérabilité sont très faciles à utiliser.
Vous pourriez être impressionné si vous ne les avez pas essayés.
Veuillez être averti de la position de Microsoft à ce sujet:
Microsoft ne recommande pas et ne prend pas en charge actuellement. Automatisation des applications Microsoft Office à partir de tout système sans assistance, Application ou composant client non interactif (y compris ASP, ASP.NET, DCOM et Services NT), car Office peut présenter unstable comportement et/ou blocage lorsque Office est exécuté dans cet environnement.
Si vous créez des fichiers Excel 2007/2010, essayez ce projet open source: https://github.com/closedxml/closedxml
Il fournit un moyen orienté objet de manipuler les fichiers (similaire à VBA) sans traiter les tracas liés aux documents XML. Ça peut être utilisé par n'importe quel langage .NET comme C # et Visual Basic (VB).
ClosedXML vous permet de créer des fichiers Excel 2007/2010 sans Excel application. L'exemple typique est 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");
Voici une bibliothèque entièrement gratuite en C #, qui vous permet d'exporter d'une DataSet, DataTable ou List<> vers un fichier .xlsx Excel 2007 authentique, à l'aide des bibliothèques OpenXML:
http://mikesknowledgebase.com/pages/CSharp/ExportToExcel.htm
Le code source complet est fourni - gratuitement - avec des instructions et une application de démonstration.
Après avoir ajouté cette classe à votre application, vous pouvez exporter votre DataSet vers Excel en une seule ligne de code:
CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");
Ça ne devient pas plus simple que ça ...
Et il n'est même pas nécessaire qu'Excel soit présent sur votre serveur.
Vous pouvez envisager de créer vos fichiers à l’aide du format XML Spreadsheet 2003 . Il s’agit d’un format XML simple utilisant un schéma bien documenté .
Syncfusion Essential XlsIO peut le faire. Il ne dépend pas de Microsoft Office et offre également un support spécifique pour différentes plates-formes.
- ASP.NET
- ASP.NET MVC
- UWP
- Xamarin
- WPF et Windows Forms
- Service Windows et opérations par lots
Exemple de code:
//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);
L'ensemble de la gamme de contrôles est disponible gratuitement via le programme licence communautaire si vous y êtes qualifié (revenus inférieurs à 1 million USD). Remarque: je travaille pour Syncfusion.
Vous voudrez peut-être jeter un oeil à GemBox.Spreadsheet .
Ils ont une version gratuite avec toutes les fonctionnalités, mais limitée à 150 lignes par feuille et à 5 feuilles par classeur, si cela correspond à vos besoins.
Je n'ai pas encore eu besoin de l'utiliser moi-même, mais ça a l'air intéressant.
OpenXML est également une bonne alternative pour éviter d’installer MS Excel sur Server. Le SDK Open XML 2.0 fourni par Microsoft simplifie la tâche de manipulation des packages Open XML et des éléments de schéma Open XML sous-jacents d’un package. L'API (Open XML Application Programming Interface) encapsule de nombreuses tâches courantes effectuées par les développeurs sur des packages Open XML.
Check this out OpenXML: Alternative permettant d'éviter l'installation de MS Excel sur le serveur
Bien,
vous pouvez également utiliser une bibliothèque tierce telle que Aspose .
Cette bibliothèque présente l'avantage de ne pas nécessiter l'installation d'Excel sur votre machine, ce qui serait idéal dans votre cas.
Les différentes bibliothèques XML Office 2003 disponibles fonctionnent plutôt bien pour les fichiers Excel plus petits. Cependant, je trouve que la taille même d'un grand classeur enregistré au format XML pose problème. Par exemple, un classeur avec lequel je travaille ferait 40 Mo dans le nouveau format XLSX (et plus compact, bien entendu) devient un fichier XML de 360 Mo.
En ce qui concerne mes recherches, il existe deux packages commerciaux qui permettent la sortie vers les formats de fichiers binaires plus anciens. Elles sont:
Ni sont bon marché (500 USD et 800 USD respectivement, je pense). mais les deux travaillent indépendamment d'Excel lui-même.
Ce que je voudrais savoir, c’est le module de sortie Excel pour OpenOffice.org, par exemple. Je me demande s’ils peuvent être portés de Java vers .Net.
Je suis d’accord pour générer des feuilles de calcul XML, voici un exemple sur la façon de le faire pour C # 3 (tout le monde écrit à son sujet dans VB 9: P) http://www.aaron-powell.com/linq- to-xml-to-Excel
Je veux juste ajouter une autre référence à une solution tierce qui règle directement votre problème: http://www.officewriter.com
(Avertissement: je travaille pour SoftArtisans, la société qui fabrique OfficeWriter)
Voici un moyen de le faire avec LINQ to XML, avec exemple de code:
Importez et exportez rapidement des données Excel avec LINQ to XML
C'est un peu complexe, car vous devez importer des espaces de noms, etc., mais cela vous permet d'éviter toute dépendance externe.
(En outre, bien sûr, il s’agit de VB .NET, pas de C #, mais vous pouvez toujours isoler les éléments VB .NET dans son propre projet pour utiliser des littéraux XML et faire tout le reste en C #.)
Vous pouvez créer des fichiers Excel au format agréable à l’aide de cette bibliothèque: http://officehelper.codeplex.com/documentation
Voir exemple ci-dessous:
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");
}
où l'échantillon ressemble à ceci:
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};
}
}
Certains fournisseurs de composants tiers, tels que Infragistics ou Syncfusion, offrent de très bonnes fonctionnalités d’exportation Excel qui ne nécessitent pas l’installation de Microsoft Excel.
Etant donné que ces fournisseurs fournissent également des composants de grille d'interface utilisateur avancés, ces composants sont particulièrement pratiques si vous souhaitez que le style et la présentation d'une exportation Excel imitent l'état actuel d'une grille dans l'interface utilisateur de votre application.
Si votre exportation est destinée à être exécutée côté serveur en mettant l'accent sur les données à exporter et sans lien vers l'interface utilisateur, je choisirais alors l'une des options libres et open source (par exemple, ExcelLibrary).
J'ai déjà participé à des projets qui tentaient d'utiliser l'automatisation côté serveur sur la suite Microsoft Office. Sur la base de cette expérience, je recommanderais fortement cette approche.
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);
}
}
}
}
Bonjour, cette solution consiste à exporter votre vue grille vers votre fichier Excel. Cela pourrait vous aider.
Je viens d’utiliser FlexCel.NET et j’ai trouvé que c’était une excellente bibliothèque! Je ne dis pas cela à propos de trop de produits logiciels. Inutile de donner ici l'intégralité de l'argumentaire de vente, vous pouvez lire toutes les fonctionnalités sur leur site web.
C'est un produit commercial, mais vous obtenez la source complète si vous l'achetez. Je suppose donc que vous pourriez le compiler dans votre assemblée si vous le souhaitiez vraiment. Sinon, c’est juste un assemblage supplémentaire à xcopy - pas de configuration ou d’installation ou quoi que ce soit du genre.
Je pense que vous ne trouverez aucun moyen de le faire sans bibliothèques tierces, car le framework .NET n’a bien évidemment pas de support intégré, et l’automatisation OLE n’est qu’un monde douloureux.
J'ai écrit un code simple pour exporter un ensemble de données vers Excel sans utiliser d'objet Excel à l'aide de System.IO.StreamWriter.
Vous trouverez ci-dessous le code qui lira toutes les tables d'un jeu de données et les écrira une à une sur des feuilles. 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();
}
Le moyen le plus simple et le plus rapide de créer un fichier Excel à partir de C # consiste à utiliser l'outil de productivité Open XML. L'outil de productivité Open XML est fourni avec l'installation du kit de développement logiciel Open XML. L'outil effectue le reverse engineering de n'importe quel fichier Excel en code C #. Le code C # peut ensuite être utilisé pour régénérer ce fichier.
Voici un aperçu du processus impliqué:
- Installez le Kit de développement Open XML SDK avec l'outil.
- Créez un fichier Excel en utilisant le dernier client Excel avec l'apparence souhaitée. Nommez-le
DesiredLook.xlsx. - Avec l'outil, ouvrez
DesiredLook.xlsxet cliquez sur le bouton de code de réflexion situé en haut .![enter image description here]()
- Le code C # de votre fichier sera généré dans le volet de droite de l'outil. Ajoutez ceci à votre solution C # et générez des fichiers avec le look souhaité.
En prime, cette méthode fonctionne pour tous les fichiers Word et PowerPoint. En tant que développeur C #, vous apporterez des modifications au code pour répondre à vos besoins.
J'ai développé une application simple WPF sur github qui fonctionnera sous Windows à cette fin. Il existe une classe d'espace réservé appelée GeneratedClass dans laquelle vous pouvez coller le code généré. Si vous revenez sur une version du fichier, un fichier Excel comme celui-ci sera généré:
Regardez des exemples pour créer des fichiers Excel.
Il y a des exemples dans C # et VB.NET
Il gère les fichiers Excel XSL XSLX et CSV.
Quelques automatisations utiles d'Excel en C #, vous pouvez trouver à partir du lien suivant.
http://csharp.net-informations.com/Excel/csharp-Excel-tutorial.htm
boulonner.
Avez-vous déjà essayé Sylk?
Nous avions l'habitude de générer des feuilles Excel en asp classique sous le nom de sylk et nous recherchons actuellement une excellente source.
Les avantages de sylk sont que vous pouvez formater les cellules.
La solution open source Java est Apache POI . Peut-être y at-il un moyen de configurer l’interopérabilité ici, mais je ne connais pas assez Java pour répondre à cette question.
Lorsque j'ai exploré ce problème, j'ai fini par utiliser les assemblages Interop.
Recherchez ExtremeML. C'est une bibliothèque plutôt cool qui vous permet d'utiliser le format OpenXML pour générer des fichiers OpenXML.
C'est aussi un projet OpenSource.
Je vote aussi pour GemBox.Spreadsheet .
Très rapide et facile à utiliser, avec des tonnes d'exemples sur leur site.
A pris mes tâches de rapport sur un tout nouveau niveau de vitesse d'exécution.
http://www.codeproject.com/KB/cs/Excel_and_C_.aspx <= pourquoi ne pas utiliser simplement la puissance intégrée de Windows, installez simplement office sur le serveur, toute application que vous installez peut être automatisée.
Tellement plus facile, utilisez simplement les méthodes natives.
Si elle est installée, vous pouvez l’utiliser. C’est là la fonction la plus impressionnante et la moins utilisée de Windows: elle a été appelée Dubbed COM à l’époque, et elle vous fait gagner beaucoup de temps et de douleur.
Ou encore plus simple, utilisez simplement les fournitures ref lib MS - http://csharp.net-informations.com/Excel/csharp-create-Excel.htm
Vous pouvez simplement l'écrire au format XML en utilisant le format XML Excel et le nommer avec l'extension .XLS. Le fichier s'ouvrira avec Excel. Vous pouvez contrôler toute la mise en forme (gras, largeur, etc.) dans l'en-tête de votre fichier XML.
Il existe un exemple XML de Wikipedia .
Une option très simple et souvent négligée consiste à créer un rapport .rdlc à l’aide de Microsoft Reporting et à l’exporter au format Excel. Vous pouvez le concevoir dans visual studio et générer le fichier en utilisant:
localReport.Render("EXCELOPENXML", null, ((name, ext, encoding, mimeType, willSeek) => stream = new FileStream(name, FileMode.CreateNew)), out warnings);
Vous pouvez également l'exporter en .doc ou .pdf, en utilisant "WORDOPENXML" et "PDF" respectivement, et il est pris en charge sur de nombreuses plates-formes différentes telles que ASP.NET et SSRS.
Il est beaucoup plus facile d'apporter des modifications à un concepteur visuel où vous pouvez voir les résultats et faites-moi confiance, une fois que vous commencez à regrouper des données, à formater des en-têtes de groupe, à ajouter de nouvelles sections, vous ne voulez pas vous mêler des dizaines de nœuds XML.
Il y a quelque temps, j'ai créé un DLL au-dessus de NPOI. C'est très simple à utiliser:
IList<DummyPerson> dummyPeople = new List<DummyPerson>();
//Add data to dummyPeople...
IExportEngine engine = new ExcelExportEngine();
engine.AddData(dummyPeople);
MemoryStream memory = engine.Export();
Vous pouvez en lire plus à ce sujet sur ici .
Au fait, c'est 100% open source. N'hésitez pas à utiliser, éditer et partager;)
Si vous créez une table de données ou datagridview à partir du code, vous pouvez enregistrer toutes les données à l’aide de cette méthode simple. Cette méthode est non recommandée mais fonctionne à 100%, même si vous n’installez pas MS Excel sur 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!");
}
vérifier cela pas besoin de bibliothèques tierces, vous pouvez simplement exporter des données datatable dans un fichier Excel à l'aide de cette
var dt = "your code for getting data into datatable";
Response.ClearContent();
Response.AddHeader("content-disposition", string.Format("attachment;filename={0}.xls", DateTime.Now.ToString("yyyy-MM-dd")));
Response.ContentType = "application/vnd.ms-Excel";
string tab = "";
foreach (DataColumn dataColumn in dt.Columns)
{
Response.Write(tab + dataColumn.ColumnName);
tab = "\t";
}
Response.Write("\n");
int i;
foreach (DataRow dataRow in dt.Rows)
{
tab = "";
for (i = 0; i < dt.Columns.Count; i++)
{
Response.Write(tab + dataRow[i].ToString());
tab = "\t";
}
Response.Write("\n");
}
Response.End();
Pour sauvegarder xls au format xlsx, il suffit d’appeler la méthode SaveAs à partir de la bibliothèque Microsoft.Office.Interop.Excel. Cette méthode prendra environ 16 paramètres, dont l’un est le format de fichier.
Document Microsoft: Ici Arguments de la méthode SaveAs
L'objet que nous devons passer 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 est sa valeur d'énumération pour XLSX
Pour SaveAs dans différents formats de fichier, vous pouvez vous référer à xlFileFormat