Comment créer un fichier Excel (.XLS et .XLSX) en C # sans installer Microsoft Office?

Comment puis-je créer une feuille de calcul Excel avec C # sans exiger qu'Excel soit installé sur la machine qui exécute le code?

Vous pouvez utiliser une bibliothèque appelée ExcelLibrary. Il s'agit d'une bibliothèque open source gratuite publiée sur Google Code:

ExcelLibrary

Cela semble être un port de PHP ExcelWriter que vous avez mentionné ci-dessus. Il n'écrira pas encore au nouveau format .xlsx, mais ils travaillent sur 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 des données Excel.

ExcelLibrary semble ne fonctionner que pour l'ancien format Excel (fichiers .xls), mais pourrait ajouter la prise en charge à l'avenir pour les nouveaux formats 2007/2010.

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 y a quelques bogues connus avec chaque bibliothèque comme indiqué dans les commentaires. Dans l'ensemble, EPPlus semble être le meilleur choix au fil du temps. Il semble également être mis à jour et documenté plus activement.

En outre, comme indiqué par @ АртёмЦарионов ci-dessous, EPPlus prend en charge les tableaux croisés dynamiques et ExcelLibrary peut avoir une certaine prise en charge ( problème de tableau croisé dynamique dans ExcelLibrary )

Voici quelques liens pour référence rapide:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Apache License

Voici un exemple 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 m'a vraiment impressionné.

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

Et qu'en est-il de l'utilisation d'Open XML SDK 2.0 pour Microsoft Office?

Quelques avantages:

• Ne nécessite pas l'installation d'Office
• 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:

• Github
• Atterrissage MSDN principal
• Page de démarrage "Comment puis-je ..."
• blogs.MSDN brian_jones annonce SDK
• blogs.MSDN brian_jones décrivant le SDK gérant des fichiers volumineux sans planter (contrairement à la méthode DOM)

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 œil à mes articles de blog:

Création de feuilles de calcul Excel .XLS et .XLSX en C #

NPOI avec tableau Excel et graphique dynamique

Vous pouvez utiliser OLEDB pour créer et manipuler des fichiers Excel. Vérifiez ceci: lire et écrire Excel en utilisant 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:

• Hé, le scripteur! Comment puis-je lire à partir d'Excel sans utiliser Excel?
• Comment utiliser ADO.NET pour récupérer et modifier des enregistrements dans un classeur Excel avec Visual Basic .NET
• Lecture et écriture de feuilles de calcul Excel à l'aide d'ADO.NET C # DbProviderFactory

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 .

Avertissement: je possède SpreadsheetGear LLC

Quelques options que j'ai utilisées:

Si XLSX est un must: ExcelPackage est un bon début mais s'est éteint lorsque le développeur a cessé de travailler dessus. ExML a repris à partir de là et a ajouté quelques fonctionnalités. ExML n'est pas une mauvaise option, je l'utilise toujours sur quelques sites de production.

Cependant, pour tous mes nouveaux projets, j'utilise NPOI , le port .NET d' Apache POI . NPOI 2.0 (Alpha) prend également en charge XLSX.

Une option extrêmement légère peut être d'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 les formules.

Je me rends compte 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 console, une application de bureau ou un service.

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 faire face aux tracas des documents XML. Il 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 l'application Excel. L'exemple typique est la création de rapports Excel sur un serveur Web:

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

Vous pouvez utiliser ExcelXmlWriter .

Ça fonctionne bien.

En fait, vous voudrez peut-être vérifier les classes d'interopérabilité disponibles en C # (par exemple Microsoft.Office.Interop.Excel. Vous dites non OLE (ce qui n'est pas le cas), mais les classes d'interopérabilité sont très faciles à utiliser. Consultez la documentation C # ici (Interop pour Excel commence le page 1072 du C # PDF).

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 actuellement et ne prend pas en charge l'automatisation des applications Microsoft Office à partir de toute application ou composant client sans assistance non interactif (y compris les services ASP, ASP.NET, DCOM et NT), car Office peut présenter un comportement instable et / ou blocage lorsque Office est exécuté dans cet environnement.

Voici une bibliothèque entièrement gratuit C #, ce qui vous permet d' exporter à partir d' un DataSet, DataTableou List<>un véritable Excel 2007 .xlsx, en utilisant les 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");

Ce n'est pas beaucoup plus simple que ça ...

Et il ne nécessite même pas la présence d'Excel sur votre serveur.

Vous pouvez envisager de créer vos fichiers en utilisant le format XML Spreadsheet 2003 . Il s'agit d'un format XML simple utilisant un schéma bien documenté .

Vous voudrez peut-être jeter un œil à GemBox. .

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 cela semble intéressant.

Syncfusion Essential XlsIO peut le faire. Il ne dépend pas de Microsoft Office et prend également en charge spécifiquement différentes plates-formes.

• ASP.NET
• ASP.NET MVC
• UWP
• Xamarin
• WPF et Windows Forms
• Service Windows et opérations par lots

Échantillon 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);

Toute la suite de contrôles est disponible gratuitement via le programme de licence communautaire si vous êtes éligible (moins de 1 million USD de revenus). Remarque: je travaille pour Syncfusion.

Bien,

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

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

OpenXML est également une bonne alternative qui permet d'éviter l'installation de MS Excel sur le serveur.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 dans un package. L'interface de programmation d'application (XML) Open XML encapsule de nombreuses tâches courantes que les développeurs effectuent sur des packages Open XML.

Découvrez OpenXML: Alternative qui évite d'installer MS Excel sur le serveur

Les diverses bibliothèques XML Office 2003 disponibles fonctionnent assez bien pour les petits fichiers Excel. Cependant, je trouve que la taille d'un grand classeur enregistré au format XML pose problème. Par exemple, un classeur avec lequel je travaille qui serait de 40 Mo dans le nouveau format XLSX (et il est vrai qu'il est plus compact) devient un fichier XML de 360 ​​Mo.

Pour autant que mes recherches m'ont mené, il existe deux packages commerciaux qui permettent la sortie vers les anciens formats de fichiers binaires. Elles sont:

• Gembox
• ComponentOne Excel

Ni sont bon marché (500USD et 800USD respectivement, je pense). mais les deux fonctionnent indépendamment d'Excel lui-même.

Ce que je serais curieux de savoir, c'est le module de sortie Excel pour OpenOffice.org. Je me demande s'ils peuvent être portés de Java vers .Net.

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 blogue à ce sujet dans VB 9: P) http://www.aaron-powell.com/linq-to-xml-to- exceller

J'ai récemment utilisé FlexCel.NET et l' ai trouvé comme une excellente bibliothèque! Je ne dis pas cela à propos de trop de produits logiciels. Inutile de donner l'intégralité 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 la source complète si vous l'achetez. Je suppose donc que vous pourriez le compiler dans votre assemblage si vous le vouliez vraiment. Sinon, c'est juste un assemblage supplémentaire pour xcopy - pas de configuration ou d'installation ou quelque chose comme ça.

Je ne pense pas que vous trouverez un moyen de le faire sans les bibliothèques tierces car le framework .NET, évidemment, n'a pas de support intégré pour cela et OLE Automation est juste un monde de difficultés.

J'ai écrit un code simple pour exporter un ensemble de données vers Excel sans utiliser d'objet Excel en utilisant System.IO.StreamWriter.

Vous trouverez ci-dessous le code qui lira toutes les tables de l'ensemble de données et les écrira 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();
    }

Je veux juste 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)

IKVM + POI

Ou, vous pouvez utiliser l'Interop ...

Voici un moyen de le faire avec LINQ to XML, 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 permet d'éviter toute dépendance externe.

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

Certains fournisseurs de composants tiers comme Infragistics ou Syncfusion offrent de très bonnes capacités d'exportation Excel qui ne nécessitent pas l'installation de Microsoft Excel.

Étant 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 disposition 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 avec l'interface utilisateur, je choisirais l'une des options open source gratuites (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 déconseille 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);
            }
        }
    }
}

Salut, cette solution consiste à exporter votre vue de grille vers votre fichier Excel, cela pourrait vous aider

Vous pouvez créer des fichiers Excel bien formatés à l'aide de 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 pour créer un fichier Excel à partir de C # est d'utiliser l'Outil de productivité Open XML. L'outil de productivité Open XML est fourni avec l'installation du kit SDK Open XML. L'outil inverse l'ingénierie de tout fichier Excel en code C #. Le code C # peut ensuite être utilisé pour recréer ce fichier.

Un aperçu du processus impliqué est:

1. Installez le SDK Open XML avec l'outil.
2. Créez un fichier Excel en utilisant le dernier client Excel avec l'apparence souhaitée. Nommez-le DesiredLook.xlsx.
3. Avec l'outil ouvert DesiredLook.xlsxet cliquez sur le bouton Reflect Code en haut.
4. Le code C # de votre fichier sera généré dans le volet droit de l'outil. Ajoutez-le à votre solution C # et générez des fichiers avec 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 ensuite des modifications au code pour répondre à vos besoins.

J'ai développé une application WPF simple sur github qui fonctionnera sur Windows à cet effet. Il existe une classe d'espace réservé appelée GeneratedClassoù vous pouvez coller le code généré. Si vous revenez en arrière une version du fichier, il générera un fichier Excel comme ceci:

Une automatisation Excel utile en C #, vous pouvez trouver à partir du lien suivant.

http://csharp.net-informations.com/excel/csharp-excel-tutorial.htm

boulonner.

Regardez des exemples sur la façon de créer des fichiers Excel.

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

Il gère les fichiers Excel XSL XSLX et CSV.

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