Excel

[sam-123]

Bonjour

Je voudrais commencer l’exportation des blocks vers un fichier Excel

J’ai rajouter la reference : « Microsoft Excel Object Library 1.6 »

Donc j’ai commencé à écrire la procédure de base

Quand je lance ma commande, Je reçois une erreur (Impossible de créer le composant ActiveX)

En vba on devais jouer avec le Resume Next:

On Error Resume Next
   Set Excelapp = GetObject(, "Excel.Application")
   If Err <> 0 Then
       Err.Clear
       Set Excelapp = CreateObject("Excel.Application")
   End If  

En Vb .Net doit-on faire de même ?

 

Ma Procedure :

_
 Public Sub MyEXcel()
       Dim MyDWG As Autodesk.AutoCAD.ApplicationServices.Document
       MyDWG = Application.DocumentManager.MdiActiveDocument
       Dim MyDb As Database
       MyDb = MyDWG.Database
       Dim MyXlApp As Microsoft.Office.Interop.Excel.Application
       Dim MyXlFeuille As Microsoft.Office.Interop.Excel.Worksheet
       MyXlApp = GetObject(, "Excel.Application")
       MyXlFeuille = MyXlApp.ActiveSheet
       Using LockDoc As DocumentLock = MyDWG.LockDocument()
           Using MyTrans As Transaction = MyDb.TransactionManager.StartTransaction
               MyXlFeuille.Cells(1, 1) = "Ligne 1"
               MyXlFeuille.Cells(2, 1) = "Ligne 2"
               MyXlFeuille.Cells(3, 1) = "Ligne 3"
               MyTrans.Commit()
           End Using
       End Using
   End Sub

 

[(gile)]

Salut,

 

Même si pour accéder à Excel avec .NET il faut utiliser l'interface COM, il faudrait essayer de cesser de raisonner : "avec VBA on faisait comme ça...".

Malgré la ressemblance de syntaxe entre VB(A) et VB.net il s'agit de deux langages différents à aborder différemment donc.

 

Ceci me conforte de plus en plus dans l'idée que ceux qui passent de VBA à .NET devrait choisir C# plutôt que VB.net pour se débarrasser plus facilement de leurs (mauvaises) habitudes et aborder .NET comme quelque chose de complètement nouveau.

 

Pour accéder à Excel (lecture ou écriture) tu peux utiliser ces classes, le fonctionnement est un peu semblable aux classes StreamReader et StreamWriter.

 

Lecture

using System;
using System.Diagnostics;
using System.IO;
using Microsoft.Office.Interop.Excel;

namespace ExcelStream
{
   /* 
    * Utilisation
    * Créer une instance de la classe : ExcelReader xlReader = new ExcelReader("C:\\Classeur1.xls");
    * Lire la feuille : while (xlReader.peek() >= 0) { string line = xlReader.ReadLine(); }
    * Fermer la processus : xlReader.Close();
    */

   public class ExcelReader
   {
       // Champs Excel
       private _Application m_Application;
       private int m_ProcessId;
       private _Workbook m_Workbook;
       private _Worksheet m_Worksheet;

       // Champs feuille
       private int m_ColumnCount;
       private int m_ColumnIndex;
       private int m_RowCount;
       private int m_RowIndex;
       private bool m_StreamEnded;

       // Propriétés
       public bool StreamEnded
       {
           get { return m_StreamEnded; }
       }

       public int Columns
       {
           get { return m_ColumnCount; }
       }

       public int Rows
       {
           get { return m_RowCount; }
       }

       public int ProcessId
       {
           get { return m_ProcessId; }
       }

       // Constructeur
       public ExcelReader()
       {
           m_ProcessId = -1;
           m_StreamEnded = false;
           m_ColumnCount = -1;
           m_ColumnIndex = -1;
           m_RowCount = -1;
           m_RowIndex = -1;
       }

       // Méthodes

       // Ferme le processus Excel
       public void Close()
       {
           m_Worksheet = null;
           m_Workbook.Close(false, Type.Missing, Type.Missing);
           m_Workbook = null;
           m_Application.DisplayAlerts = true;
           m_Application.Quit();
           m_Application = null;
           Process.GetProcessById(m_ProcessId).Kill();
           m_ProcessId = -1;
       }

       // Ouvre le processus Excel et le fichier donné (surchargé)
       public void Open(string Filename)
       {
           this.Open(Filename, null);
       }

       public void Open(string filename, string WorksheetName)
       {
           Process[] ExcelProcessBefore = Process.GetProcessesByName("EXCEL");
           m_Application = new ApplicationClass();
           Process[] ExcelProcessAfter = Process.GetProcessesByName("EXCEL");
           m_ProcessId = GetProcessId(ExcelProcessBefore, ExcelProcessAfter);
           m_Application.DisplayAlerts = false;

           m_Workbook = m_Application.Workbooks.Open(
               filename, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
               Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
               Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
           m_Worksheet = string.IsNullOrEmpty(WorksheetName) ?
               (_Worksheet)m_Workbook.ActiveSheet :
               GetWorksheet(WorksheetName);
           SetWorksheetAttributes();
       }

       // Retourne la position de la prochaine cellule sans avancer le lecteur
       // Retourne -1 si le lecteur est à la fin de la feuille
       public int Peek()
       {
           if (m_StreamEnded)
               return -1;
           if (m_ColumnIndex             {
               return m_ColumnCount * (m_RowIndex - 1) + m_ColumnIndex;
           }
           else
           {
               m_StreamEnded = true;
               return -1;
           }
       }

       // Retourne le contenu de la cellule sur laquelle est le lecteur et avance le lecteur
       // Lève EndOfStreamException si le lecteur est à la fin de la feuille
       public string Read()
       {
           if (!m_StreamEnded)
           {
               string value = string.Empty;
               Range cell = (Range)m_Worksheet.Cells[m_RowIndex, m_ColumnIndex];
               value = cell.Value2 != null ? cell.Value2.ToString() : string.Empty;

               if (m_ColumnIndex == m_ColumnCount)
               {
                   if (m_RowIndex                     {
                       m_RowIndex++;
                       m_ColumnIndex = 1;
                   }
                   else
                       m_StreamEnded = true;
               }
               else
                   m_ColumnIndex++;
               return value;
           }
           else
               throw new EndOfStreamException();
       }

       // Retourne le contenu d'une ligne entière sous forme d'un array de chaînes et 
       // avance le lecteur à la ligne suivante.
       // Lève EndOfStreamException si le lecteur est à la fin de la feuille
       public string[] ReadLine()
       {
           if (!m_StreamEnded)
           {
               string[] values = new string[m_ColumnCount];
               for (int i = 0; i                 {
                   Range cell = (Range)m_Worksheet.Cells[m_RowIndex, i + 1];
                   values[i] = cell.Value2 != null ? cell.Value2.ToString() : string.Empty;
               }
               if (m_RowIndex                 {
                   m_RowIndex++;
                   m_ColumnIndex = 1;
               }
               else
                   m_StreamEnded = true;
               return values;
           }
           else
               throw new EndOfStreamException();
       }

       public void CopyToClipBoard()
       {
           m_Worksheet.UsedRange.Copy(Type.Missing);
       }

       // Retourne l'identifiant du processus présent dans le deuxième paramètre et absent du premier.
       private int GetProcessId(Process[] ExcelProcessBefore, Process[] ExcelProcessAfter)
       {
           bool isThisProcess = false;
           int result = -1;
           if (ExcelProcessBefore.Length == 0 && ExcelProcessAfter.Length == 1)
               result = ExcelProcessAfter[0].Id;
           else
           {
               foreach (Process processAfter in ExcelProcessAfter)
               {
                   isThisProcess = true;
                   foreach (Process processBefore in ExcelProcessBefore)
                   {
                       if (processAfter.Id == processBefore.Id)
                       {
                           isThisProcess = false;
                       }
                   }
                   if (isThisProcess)
                       result = processAfter.Id;
               }
           }
           return result;
       }

       // Retourne l'instance de la feuille donnée en paramètre, null si elle n'existe pas.
       private _Worksheet GetWorksheet(string worksheetName)
       {
           foreach (_Worksheet worksheet in m_Workbook.Worksheets)
           {
               if (worksheet.Name == worksheetName)
                   return worksheet;
           }
           m_StreamEnded = true;
           return null;
       }

       // Met à jour les nombres de lignes et de colonnes et la position du lecteur.
       private void SetWorksheetAttributes()
       {
           m_RowIndex = 1;
           m_ColumnIndex = 1;
           Range usedRange = m_Worksheet.UsedRange;
           m_RowCount = usedRange.Rows.Count;
           m_ColumnCount = usedRange.Columns.Count;
           if (m_RowCount == 1 && m_ColumnCount == 1)
           {
               Range cell = (Range)m_Worksheet.Cells[1, 1];
               if (cell.Value2 == null || (string)cell.Value2 == string.Empty)
                   m_StreamEnded = true;
           }
       }
   }
}

 

Écriture

using System;
using System.Diagnostics;
using System.IO;
using Microsoft.Office.Interop.Excel;

namespace ExcelStream
{
   /* 
    * Utilisation
    * Créer une instance de la classe : ExcelWriter xlWriter = new ExcelWriter("C:\\Classeur1.xls");
    * Ecrire une ligne : xlWriter.WriteLine(new string[4] {"Ceci", "est", "un", "test"});
    * Fermer la processus : xlWriter.Close();
    */

   public class ExcelWriter
   {
       // Champs Excel
       private _Application m_Application;
       private int m_ProcessId;
       private _Workbook m_Workbook;
       private _Worksheet m_Worksheet;

       // Champs feuille
       private int m_ColumnCount;
       private int m_ColumnIndex;
       private int m_RowCount;
       private int m_RowIndex;
       private bool m_StreamEnded;

       // Propriété
       public bool EndOfStream
       {
           get { return m_StreamEnded; }
       }

       public int ProcessId
       {
           get { return m_ProcessId; }
       }

       // Constructeur
       public ExcelWriter()
       {
           m_ProcessId = -1;
           m_StreamEnded = false;
           m_ColumnCount = -1;
           m_ColumnIndex = -1;
           m_RowCount = -1;
           m_RowIndex = -1;
       }

       // Méthodes

       // Ferme le processus Excel
       public void Close()
       {
           m_Worksheet = null;
           m_Workbook.Save();
           m_Workbook.Close(false, Type.Missing, Type.Missing);
           m_Workbook = null;
           m_Application.DisplayAlerts = true;
           m_Application.Quit();
           m_Application = null;
           Process.GetProcessById(m_ProcessId).Kill();
           m_ProcessId = -1;
       }

       // Ouvre le processus Excel et le fichier donné (surchargé)
       public void Open(string filename)
       {
           Open(filename, null);
       }

       public void Open(string filename, string worksheetName)
       {
           Process[] excelProcessBefore = Process.GetProcessesByName("EXCEL");
           m_Application = new ApplicationClass();
           Process[] excelProcessAfter = Process.GetProcessesByName("EXCEL");
           m_ProcessId = GetProcessId(excelProcessBefore, excelProcessAfter);
           m_Application.DisplayAlerts = false;

           if (File.Exists(filename))
               m_Workbook = m_Application.Workbooks.Open(
                   filename, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                   Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                   Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
           else
           {
               m_Workbook = m_Application.Workbooks.Add(Type.Missing);
               m_Workbook.SaveAs(
                   filename, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                   Type.Missing, XlSaveAsAccessMode.xlNoChange, Type.Missing,
                   Type.Missing, Type.Missing, Type.Missing, Type.Missing);
           }

           if (string.IsNullOrEmpty(worksheetName))
               m_Worksheet = (_Worksheet)m_Workbook.ActiveSheet;
           else
               m_Worksheet = GetWorksheet(worksheetName);

           SetWorksheetAttributes();
       }

       // Change de ligne
       public void NewLine()
       {
           if (!m_StreamEnded)
           {
               if (m_RowIndex                 {
                   m_RowIndex++;
                   m_ColumnIndex = 1;
               }
               else
                   m_StreamEnded = true;
           }
           else
               throw new EndOfStreamException();
       }

       // Ecrit la valeur donnée dans la cellule courante et avance d'une cellule 
       // ou change de ligne s'il arrive à la fin d'une ligne.
       public void Write(string value)
       {
           if (!m_StreamEnded)
           {
               ((Range)m_Worksheet.Cells[m_RowIndex, m_ColumnIndex]).Value2 = value;
               if (m_ColumnIndex == m_ColumnCount)
               {
                   if (m_RowIndex                     {
                       m_RowIndex++;
                       m_ColumnIndex = 1;
                   }
                   else
                       m_StreamEnded = true;
               }
               else
                   m_ColumnIndex++;
           }
           else
               throw new EndOfStreamException();
       }

       // Ecrit un ensemble de valeurs donné sous forme de tableau dans des cellules,
       // puis change de ligne à la fin.
       public void WriteLine(string[] values)
       {
           if (!m_StreamEnded)
           {
               foreach (string str in values)
               {
                   if (m_ColumnIndex                     {
                       ((Range)m_Worksheet.Cells[m_RowIndex, m_ColumnIndex]).Value2 = str;
                       if (m_ColumnIndex                             m_ColumnIndex++;
                   }
               }
               if (m_RowIndex                 {
                   m_RowIndex++;
                   m_ColumnIndex = 1;
               }
           }
           else
               throw new EndOfStreamException();
       }

       public void PasteFromClipboard()
       {
           m_Worksheet.Paste(m_Worksheet.Cells[1, 1], false);
       }

       // Retourne l'identifiant du processus présent dans le deuxième paramètre et absent du premier.
       private int GetProcessId(Process[] ExcelProcessBefore, Process[] ExcelProcessAfter)
       {
           bool isThisProcess = false;
           int result = -1;
           if (ExcelProcessBefore.Length == 0 && ExcelProcessAfter.Length == 1)
               result = ExcelProcessAfter[0].Id;
           else
           {
               foreach (Process processAfter in ExcelProcessAfter)
               {
                   isThisProcess = true;
                   foreach (Process processBefore in ExcelProcessBefore)
                   {
                       if (processAfter.Id == processBefore.Id)
                       {
                           isThisProcess = false;
                       }
                   }
                   if (isThisProcess)
                       result = processAfter.Id;
               }
           }
           return result;
       }

       // Retourne l'instance de la feuille donnée en paramètre, l'ajoute si elle n'existe pas.
       private _Worksheet GetWorksheet(string worksheetName)
       {
           foreach (_Worksheet worksheet in m_Workbook.Worksheets)
           {
               if (worksheet.Name == worksheetName)
                   return worksheet;
           }
           _Worksheet newWorksheet =
               (_Worksheet)m_Workbook.Worksheets.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);
           newWorksheet.Name = worksheetName;
           return newWorksheet;
       }

       // Met à jour les nombres de lignes et de colonnes et la position de l'écrivain.
       private void SetWorksheetAttributes()
       {
           m_RowCount = m_Worksheet.Rows.Count;
           m_RowIndex = 1;
           m_ColumnCount = m_Worksheet.Columns.Count;
           m_ColumnIndex = 1;
       }
   }
}

[sam-123]

Salut,

Si je dois transmettre en ta classe en vbnet avant la fin de la journée j’aurais attrapé des cheveux gris. :o

Je pensais à quelque chose de plus simple : ;)

Dim MyXlApp = New Excel._ExcelApplication
Dim MyXlClasseur = MyXlApp.Workbooks
Dim MyXlFeuille = MyXlApp.Worksheets
MyXlClasseur = MyXlApp.Workbooks.Open("C:\\Test.xls", Nothing, Nothing, Nothing, Nothing, Nothing, _
                                     Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing)
MyXlFeuille = MyXlApp.ActiveSheet

[(gile)]

Je pensais à quelque chose de plus simple

 

Programmer Excel n'est pas simple, si tu démarres un processus Excel, en plus d'enregistrer et de fermer le fichier que tu as ouvert (ou créé) il faut aussi arrêter le processus. Regarde la méthode Close() des classes ci-dessus, elle appelle la méthode Kill() pour arrêrer le processus, mais il faut être sûr d'arrêter le bon processus, d'où la méthode GetProcessId(). Tu vois, ce n'est pas si simple...

 

Si tu veux vraiment faire simple (et rapide) pour écrire (ça ne marche pas pour lire) un fichier Excel, pour te parodier je dirais : fais comme on fait en LISP, écrits dans le fichier comme tu le ferais dans un fichier texte avec la classe System.IO.StreamWriter et la tabulation comme séparateur de données ("\t" en LISP ou C#):

 

using(StreamWriter writer = new StreamWriter("C:\\TestExcel.xls"))
{
   writer.WriteLine("A1\tB1\tC1");
   writer.WriteLine("A2\tB2\tC2");
   writer.Close();
}

[sam-123]

Je ne comprends pas très bien, pourquoi on ne ferait pas simplement ceci

Dim MyXlApp As New Excel.Application
Dim MyXlClasseur As Excel.Workbook
Dim MyXlFeuille As Excel.Worksheet

MyXlClasseur = MyXlApp.Workbooks.Open("C:\Test.xls")
MyXlFeuille = MyXlClasseur.ActiveSheet
MyXlFeuille.Cells(1, 1) = "Test"
. . .
. . .
 

Et naturellement on fermerait manuellement

[(gile)]

Si ça te conviens, pourquoi pas.

 

Personnellement, je suis loin d'être un spécialiste de la programmation Excel et, à vrai dire, ça me gonfle un peu.

La plupart du temps, l'utilisation de fichiers CSV serait autrement plus efficace et quand il s'agit de traitement de données plus sérieux, autant utiliser de vraies bases de données...

[sam-123]

Oh !, ca me conviendrais parfaitement si ca ne bloque pas !!!

Je n’arrive pas à voir ce qui ne fonctionnent pas dans cette procédure, ca bloque sur la ligne n°4 (l’ouverture du fichier)

 

   MyXlClasseur = MyXlApp.Workbooks.Open("C:\Test.xls")   

 

 

[Edité le 12/4/2010 par sam-123]

[(gile)]

Tu codes avec Visual Studio ?

Si oui, sert toit de l'intellisense qui te donne les propriétés et méthodes des instances de classe quand tu tapes le point après l'instance et les arguments (paramètres) des méthodes quand tu ouvres une parenthèse.

 

L'interface : Microsoft.Office.Interop.Excel.Workbook (si c'est bien celle que instancies, difficile à dire avec le peu que tu montres...) n'a pas de méthode Open(), elle a un évènement Open...

[sam-123]

Désole, Avec ca je ne suis pas plus avancé ! :question:

[sam-123]

Finalement j’ai finie par trouver :red:

Il fallait mettre la variable « System.Globalization.CultureInfo » sur « en-US »