Ecrire un fichier XLS sans utiliser Excel

Version imprimable

20/11/2009, 13h43
Arsou

Ecrire un fichier XLS sans utiliser Excel

Bonjour à tous :).

J'ai fait quelques recherche rapide sur le sujet et je n'ai pas trouver de tutorial explicite à ce sujet (mais honte sur moi j'ai pas chercher beaucoup :D).

Voici donc un petit code permettant de crée des fichiers XLS lisible sous excel sans pour autant avoir excel installé sur la machine de l'utilisateur final.
Le fichier XLS est ensuite parfaitement lisible par excel mais, petit bémol, pas par open office qui le considère comme un fichier XML Oo.

pour ce faire, il est nécessaire d'utiliser une DLL codée par Carlos Aguilar Mares, elle est gratuite et disponible sur la page de l'auteur.

L'écriture

Je commence avec le gros morceau: la création du fichier et l'écriture de la première page:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
        internal static void WriteXlsFile(BackgroundWorker pWorker, string pFileName, DataTable pValueDT, DataTable pInfoDT)
        {
            Workbook Book = new CarlosAg.ExcelXmlWriter.Workbook(); 
 
            WorksheetStyle NormalStyle = Book.Styles.Add("Normal");
            WorksheetStyle BoldStyle = Book.Styles.Add("Bold");
            BoldStyle.Font.Bold = true;
 
            Worksheet InfoSheets = Book.Worksheets.Add("Information"); 
 
            InfoSheets.Table.Rows.Add();
            foreach (DataRow myDR in pInfoDT.Rows)
            {
                WorksheetRow Row = new WorksheetRow();
                for (int i = 0; i < pInfoDT.Columns.Count; i++)
                {
                    Row.Cells.Add(myDR[i].ToString(), DataType.String, "Normal");
                }
                InfoSheets.Table.Rows.Add(Row);
            }
 
 
            Worksheet ValueSheets = Book.Worksheets.Add("Nom");
 
            WorksheetRow WRow = new WorksheetRow();
 
            pWorker.ReportProgress(40);
 
            foreach (DataColumn myDC in pValueDT.Columns)
            {
                WRow.Cells.Add(myDC.ColumnName, DataType.String, "Bold");
            }
            ValueSheets.Table.Rows.Add(WRow);
 
 
            pWorker.ReportProgress(60);
 
            foreach (DataRow myDR in pValueDT.Rows)
            {
                WorksheetRow Row = new WorksheetRow();
                for (int i = 0; i < pValueDT.Columns.Count; i++)
                {
                    Row.Cells.Add(myDR[i].ToString());
                }
                ValueSheets.Table.Rows.Add(Row);
            }
 
            try
            {
                Book.Save(pFileName + @".Xls");
                File.SetAttributes(pFileName + @".Xls", FileAttributes.ReadOnly);
                pWorker.ReportProgress(80);
                return ReadXlsFile(pFileName);
            }
            catch (Exception Ex)
            {
 
                throw Ex;
            }
        }

La fonction prend plusieurs paramètre en entrée:
- Un background worker: la fonction pouvant prendre au mieux 5 secondes de traitement, il permet d'éviter de figer votre UI (plus d'information à ce sujet: ici )
- Un string contenant le nom du fichier.
- Un datatable contenant les valeurs de la feuille à ajouter.
- Un datatable contenant les informations (page de garde etc)

Alors décorticage du code ^^:

Code:

Workbook Book = new CarlosAg.ExcelXmlWriter.Workbook();

Création du nouveau classeur

Code:

1
2
3
WorksheetStyle NormalStyle = Book.Styles.Add("Normal");
            WorksheetStyle BoldStyle = Book.Styles.Add("Bold");
            BoldStyle.Font.Bold = true;

Définition des styles d'écriture.

Code:

Worksheet InfoSheets = Book.Worksheets.Add("Information");

Création de la feuille (nomée ici "information" puisqu'elle va contenir la page... d'information, merci ceux qui suive :mouarf:)

Code:

1
2
3
4
5
6
7
8
9
10
InfoSheets.Table.Rows.Add();
            foreach (DataRow myDR in pInfoDT.Rows)
            {
                WorksheetRow Row = new WorksheetRow();
                for (int i = 0; i < pInfoDT.Columns.Count; i++)
                {
                    Row.Cells.Add(myDR[i].ToString(), DataType.String, "Normal");
                }
                InfoSheets.Table.Rows.Add(Row);
            }

Je saute une ligne qui, dans les autres feuille, est la ligne des titres.
Ensuite viens deux boucle imbriquée, la boucle intérieur ajoute toutes les cellules dans la ligne (Row). La boucle extérieur quand à elle, crée puis ajoute la Row remplie par la boucle intérieur.

Code:

1
2
3
4
5
6
7
8
9
 WorksheetRow WRow = new WorksheetRow();
 
            pWorker.ReportProgress(40);
 
            foreach (DataColumn myDC in pValueDT.Columns)
            {
                WRow.Cells.Add(myDC.ColumnName, DataType.String, "Bold");
            }
            ValueSheets.Table.Rows.Add(WRow);

Cette boucle crée la ligne des titres de la page en cours.

Code:

1
2
3
4
5
6
7
8
9
10
11
try
            {
                Book.Save(pFileName + @".Xls");
                File.SetAttributes(pFileName + @".Xls", FileAttributes.ReadOnly);
                pWorker.ReportProgress(80);
            }
            catch (Exception Ex)
            {
 
                throw Ex;
            }

Cela sauve le fichier et le passe en "lecture seule" afin de limité les modifications extérieur.

Ensuite voici la mise à jour d'un fichier existant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
internal static Void WriteXlsFile(BackgroundWorker pWorker, string pFileName, DataTable pValueDT)
        {
            Workbook TamponBook = new Workbook();//Creates a stamp book
 
            WorksheetStyle NormalStyle = TamponBook.Styles.Add("Normal");
            WorksheetStyle BoldStyle = TamponBook.Styles.Add("Bold");
            BoldStyle.Font.Bold = true;
 
            Worksheet ValueSheets = TamponBook.Worksheets.Add("Nom");
 
            WorksheetRow WRow = new WorksheetRow();
 
            foreach (DataColumn myDC in pValueDT.Columns)
            {
                WRow.Cells.Add(myDC.ColumnName, DataType.String, "Bold");
            }
            ValueSheets.Table.Rows.Add(WRow);
 
            pWorker.ReportProgress(40);
 
            foreach (DataRow myDR in pValueDT.Rows)
            {
                WorksheetRow Row = new WorksheetRow();
                for (int i = 0; i < pValueDT.Columns.Count; i++)
                {
                    Row.Cells.Add(myDR[i].ToString(), DataType.String, "Normal");
                }
                ValueSheets.Table.Rows.Add(Row);
            }
 
            pWorker.ReportProgress(60);
 
            Workbook Book = new Workbook();
            Book.Load(pFileName + @".Xls");
            Book.Worksheets.Insert(1, ValueSheets);
 
            try
            {
                File.SetAttributes(pFileName + @".Xls", FileAttributes.Normal);
                Book.Save(pFileName + @".Xls");
                File.SetAttributes(pFileName + @".Xls", FileAttributes.ReadOnly);
                pWorker.ReportProgress(80);
                return ReadXlsFile(pFileName);
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
        }

Ce code est pratiquement le même que celui du dessus à quelques détail prés:

Une feuille "tampon" est crée et c'est sur cette feuille que seront chargé les données.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Workbook Book = new Workbook();
            Book.Load(pFileName + @".Xls");
            Book.Worksheets.Insert(1, ValueSheets);
 
            try
            {
                File.SetAttributes(pFileName + @".Xls", FileAttributes.Normal);
                Book.Save(pFileName + @".Xls");
                File.SetAttributes(pFileName + @".Xls", FileAttributes.ReadOnly);
                pWorker.ReportProgress(80);
                return ReadXlsFile(pFileName);
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
        }

Le classeur est crée et charge le fichier existant et puis il insert la feuille tampon (en deuxième place, toujours :) ).
Il est possible de changer la place de la fueille dans le ligne:

Code:

Book.Worksheets.Insert(1, ValueSheets);

le chiffre étant la page précédant la page insérée.

Je repasse évidemment le fichier en lecture/écriture avant de sauvegarder.

ATTENTION!

les parties de code qui définissent le nom de la feuille

Code:

Worksheets.Add("Nom");

dois à chaque fois contenir une valeur différente car deux feuilles ne peuvent pas avoir le même nom.

Voila, je pensai également ajouter la lecture du fichier avec cette DLL mais le code que j'ai utiliser est brouillon et pas très propre donc je préfère m'abstenir pour le moment, je reviendrai dessus un peu plus tard :).

Bonne lecture et n'hésiter pas à commenter/corriger.

24/11/2009, 12h15
Philippe Vialatte

euh...en fait, je viens d'ecrire un article contenant entre autres un bout de code faisant ca, mais oriente asp.net, et sans trop creuser (et pis il est pas encore publie, alors... ;) )

Niveau remarques, je ne trouve pas la fonction ReadXlsFile (dommage, elle est utilisee partout), et tu as un pb de coherence dans le nommage de tes variables (qui devraient toutes etre en camelCase)

Sinon, a quand un article ?
01/12/2009, 21h06
Arsou

Effectivement, c'est une erreur de ma part, normalement ReadXML devrai lire le contenu du fichier XLS malheureusement j'ai oublier de la retirer quand j'ai copier/coller le code :s . Je corrigerai ça sous peu :?.

Effectivement j'ai un peu mélanger Camel et Pascal case , je repasserai dessus en même temps que mes corrections (mais pas ce soir :s).

Maintenant pour ce qui est de ton article, je ne pense pas que les deux vont se gêner car il me semble que l'ASP travaille différemment. Dans tout les cas je ne vais pas venir pleurer parce qu'on a copier une partie de mon code dans un autre article, tant que le dis article est la pour aider la communauté.

Et à la question " A quand l'article?" Ben ca faut voir avec un des rédacteurs C# :mouarf:

Voilou.
01/12/2009, 22h26
Philippe Vialatte

Citation:

Maintenant pour ce qui est de ton article, je ne pense pas que les deux vont se gêner car il me semble que l'ASP travaille différemment. Dans tout les cas je ne vais pas venir pleurer parce qu'on a copier une partie de mon code dans un autre article, tant que le dis article est la pour aider la communauté.

Je te rassure, si c'est le cas, ce serait plus de l'ordre de la coïncidence que du plagiat ;)