Comment créer un fichier Excel (.XLS et .XLSX) en C# sans installer Microsoft Office ?[fermé]
https://stackoverflow.com/questions/151005
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Comment puis-je créer une feuille de calcul Excel avec C# sans nécessiter l’installation d’Excel sur la machine qui exécute le code ?
La solution
Vous pouvez utiliser une bibliothèque appelée ExcelLibrary. C'est une bibliothèque libre et gratuite 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 possède 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.
Vous pouvez également utiliser EPPlus , qui ne fonctionne que pour les fichiers au format Excel 2007/2010 (fichiers .xlsx ). Il existe également un 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 même, comme indiqué par @ & # 1040; & # 1088; & # 1090; & # 1105; & # 1084; & # 1062; & # 1072 ; & # 1088; & # 1080; & # 1086; & # 1085; & # 1086; & # 1074; ci-dessous, EPPlus prend en charge les tableaux croisés dynamiques et ExcelLibrary peut en prendre une certaine part ( problème de tableau croisé dynamique dans ExcelLibrary )
Voici quelques liens pour une référence rapide:
ExcelLibrary - GPL GNU Lesser
EPPlus - Licence publique générale limitée GNU (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é.
Autres conseils
Si vous êtes satisfait du format xlsx, essayez mon projet GitHub, EPPlus . Cela a commencé avec le source de ExcelPackage, mais aujourd'hui, c'est une réécriture totale. Il prend en charge les plages, le style de cellule, les graphiques, les formes, les images, les plages nommées, 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 (version bêta) prend également en charge XLSX.
Jetez un coup d'œil à mes articles de blog:
Et qu'en est-il de l'utilisation du Kit de développement Open XML SDK 2.0 pour Microsoft Office?
Quelques avantages:
- Office ne doit pas être installé
- Fabriqué par Microsoft = documentation MSDN correcte
- Une seule DLL .Net à utiliser dans le projet
- Le SDK est livré avec de nombreux outils comme diff, validator, etc.
Liens:
- Télécharger le SDK
- atterrissage principal MSDN
- & "Comment puis-je .. . " page de démarrage
- blogs.MSDN brian_jones annonce du SDK
- blogs.MSDN brian_jones décrivant le SDK traitant des fichiers volumineux sans planter (contrairement à la méthode DOM)
Vous pouvez utiliser OLEDB pour créer et manipuler des fichiers Excel. Vérifiez ceci: Lecture et écriture d'Excel à l'aide d'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 liens supplémentaires:
La solution commerciale SpreadsheetGear pour .NET le fera.
Vous pouvez voir des exemples en direct d'ASP.NET (C # et VB) ici et télécharger un fichier version d'évaluation ici .
Clause de non-responsabilité: je possède SpreadsheetGear LLC
Quelques options que j'ai utilisées:
Si XLSX est indispensable: ExcelPackage est un bon début, mais il est mort lorsque le développeur cesser de travailler dessus. ExML a ramassé à partir de là et ajouté quelques fonctionnalités. ExML n'est pas une mauvaise option, je l'utilise encore dans quelques sites de production. .
Pour tous mes nouveaux projets, toutefois, j'utilise NPOI , le port .NET de POI Apache . 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. Vous pouvez utiliser des attributs spécifiques à Microsoft pour styliser la sortie, notamment les formules.
Je réalise que vous ne codifiez peut-être pas cela dans une application Web, mais voici un exemple de 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 .
Cela fonctionne bien.
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");
Vous voudrez peut-être consulter les classes d'interopérabilité . 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ées.
Veuillez noter que position à ce sujet:
Microsoft ne recommande pas actuellement et ne prend pas en charge, Automatisation des applications Microsoft Office à partir de toute installation sans surveillance, application ou composant client non interactif (y compris ASP, ASP.NET, DCOM et NT), car Office peut être instable comportement et / ou blocage lorsque Office est exécuté dans cet environnement.
Voici une bibliothèque entièrement gratuite en C #, qui vous permet d'exporter à partir d'un DataSet, DataTable ou List<> fichier dans un fichier .xlsx authentique Excel 2007, à 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");
Cela ne devient pas beaucoup plus simple que ça ...
Et Excel n’a même pas besoin d’être présent sur votre serveur.
Vous pouvez envisager de créer vos fichiers au format de la feuille de calcul XML 2003 . Il s’agit d’un format XML simple utilisant schéma bien documenté .
Vous pouvez consulter 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 vous convient.
Je n'ai pas encore eu besoin de l'utiliser moi-même, mais ça a l'air intéressant.
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 des contrôles est disponible gratuitement via le programme licence de communauté si vous êtes qualifié ( moins de 1 million USD de revenus). Remarque: je travaille pour Syncfusion.
Eh 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 ordinateur, ce qui serait idéal dans votre cas.
Les différentes bibliothèques XML Office 2003 disponibles fonctionnent plutôt bien pour les petits fichiers Excel.Cependant, je trouve que la taille même d'un classeur volumineux enregistré au format XML pose problème.Par exemple, un classeur avec lequel je travaille et qui ferait 40 Mo dans le nouveau format XLSX (et certes plus compact) devient un fichier XML de 360 Mo.
D'après mes recherches, il existe deux packages commerciaux qui permettent la sortie vers les anciens formats de fichiers binaires.Ils sont:
Ni l’un ni l’autre ne sont bon marché (respectivement 500 USD et 800 USD, je pense).mais les deux fonctionnent indépendamment d'Excel lui-même.
Ce qui m'intéresserait, c'est le module de sortie Excel pour OpenOffice.org.Je me demande s'ils peuvent être portés de Java vers .Net.
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 que les développeurs effectuent sur des packages Open XML.
Découvrez cette OpenXML: une alternative qui évite d'installer MS Excel sur le serveur
Je suis d’accord sur la génération de feuilles de calcul XML, voici un exemple sur la façon de le faire pour C # 3 (tout le monde en parle dans VB 9: P) http://www.aaron-powell.com/linq-to-xml-to-excel
J'ai récemment utilisé 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 en obtenez la source complète si vous l’achetez. Donc, je suppose que vous pourriez le compiler dans votre assemblée si vous le vouliez vraiment. Sinon, c’est juste un assemblage supplémentaire à xcopy - pas de configuration, 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 OLE Automation n’est qu’un monde douloureux.
Vous souhaitez simplement ajouter une autre référence à une solution tierce qui résout directement votre problème: http://www.officewriter.com
(Avertissement: je travaille pour SoftArtisans, la société qui fabrique OfficeWriter)
J'ai écrit un code simple pour exporter un jeu de données vers Excel sans utiliser d'objet Excel à l'aide de System.IO.StreamWriter.
Le code ci-dessous lit toutes les tables de l’ensemble de données et les écrit sur des 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 un moyen de le faire avec LINQ to XML, complet avec un 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 évite 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 #.)
Certains fournisseurs de composants tiers, tels que Infragistics ou Syncfusion, offrent de très bonnes capacité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 utiles si vous souhaitez que le style et la présentation d'une exportation Excel reproduisent 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 l'une des options libres open source (par exemple, ExcelLibrary).
J'ai déjà été impliqué dans 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 de grille dans votre fichier Excel. Cela pourrait vous aider
. Vous pouvez créer des fichiers Excel bien formatés en utilisant cette bibliothèque:
http://officehelper.codeplex.com/documentation
Voir l'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};
}
}
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 tout fichier Excel en code C #. Le code C # peut ensuite être utilisé pour régénérer ce fichier.
Un aperçu du processus impliqué est le suivant:
- 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’aspect souhaité. Nommez-le
DesiredLook.xlsx. - Ouvrez l'outil
GeneratedClasset cliquez sur le bouton Code de réflexion situé en haut.
- Le code C # de votre fichier sera généré dans le volet de droite de l'outil. Ajoutez-le à votre solution C # et générez des fichiers ayant l'apparence souhaitée.
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 WPF simple sur github qui s'exécutera sous Windows à cette fin. Il existe une classe d'espace réservé appelée <=> où 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é:
Vous trouverez quelques informations utiles sur l’automatisation d’Excel en C # à partir du lien suivant.
http://csharp.net-informations.com/excel/ csharp-excel-tutorial.htm
Bolton.
Regardez des exemples pour créer des fichiers Excel.
Il existe des exemples dans C # et VB.NET
.Il gère les fichiers Excel XSL XSLX et CSV.
