Fehler bei Excel.workbooks.Open (...)

[Andreas Leix]

Hallo zusammen !

Arbeite unter delphi2007. Habe mir Routinen geschrieben um in eine bestehende Excel-Datei
Daten reinzuschreiben. Das klappt wunderbar mit Excel 2007. Auf anderen Rechnern ist aber Excel 2000 drauf
und da läuft mein Programm nicht .

Dazu verwende ich folgenden Code

Delphi-Quellcode:

uses ExcelXP; 
...
var Excel  : TExcelApplication;
    WB     : _WorkBook;
...
  WB:= Excel.Workbooks.Open (strDokument, emptyParam, emptyParam, emptyParam, emptyParam,
                              emptyParam, emptyParam, emptyParam, emptyParam, emptyParam, emptyParam,
                              emptyParam, emptyParam,emptyParam, emptyParam,lcid );

Wie gesagt mit Excel 2007 läuft das Prima,
mit Excel2000 gibts bei "Workbooks.Open" einen Laufzeitfehler ( "Zugriffsverletzung ....")

Nun habe ich bezgl workbooks.Open schon gelesen, dass sich da die ANZAHL der Aufrufparameter geändert hat.

Wie kann man denn mit sowas umgehen. Mein Programm soll ja auf verschiedensten Ziel-systemen mit evtl. unterschiedlichen Excel-Versionen laufen.

Die Excel-Version könnte ich zu Laufzeit wahrscheinlich noch irgendwie bestimmen,
aber was mach ich mit dem Aufruf von Workbooks.Open ?
Der läßt sich ja nur mit genau der Anzahl von Parametern compilieren!

Da ist doch ein allgemeines Problem beim Einbinden der Unit ExcelXP, oder ?


Hat jemand eine Ahnung ?

Gruß Andreas

[Errraddicator]

Warum gibste überhaupt die ganzen Leerparameter mit an?
Kannste nich einfach nur Workbooks.Open('Name') schreiben?

...

Edit:
Achso Du nutzt diese TExcelApplication Klasse.
Sah mir zuerst nach OLE aus.

[mkinzler]

Zitat:

Achso Du nutzt diese TExcelApplication Klasse.
Sah mir zuerst nach OLE aus.

Die Klasse verwendet ebenfalls OLE. Es handelt sich halt nur um frühe Bindung

[Andreas Leix]

Würde ich mit "später Bindung" um das Problem herum kommen ?

Wenn ja , wie stell ich das an?


Gruß Andreas

[Errraddicator]

Also ich mache es im Moment so...

Delphi-Quellcode:

procedure prod();
var
  vExcel: Variant;
  vWorkbook: Variant;
  vWorksheet: Variant;
  rowIdx: Integer;
begin
  CoInitialize(nil);
  try
    vExcel     := CreateOleObject('Excel.Application');
    vWorkbook  := vExcel.Workbooks.Open('Datenquelle.xls');
    vWorksheet := vWorkbook.ActiveSheet;

    rowIdx := 2;
    while <SonstWas> do
    begin
      ShowMessage(vWorksheet.Cells[rowIdx, 3]);
    // usw halt

Sprich Du machst für jedes Objekt was Du direkt brauchst eine Variable vom Typ Variant und kannst dann mehr oder weniger direkt VBA programmieren.
Der Compiler kennt die Funktionen dann allerdings natürlich nich, d.h. der meckert falsch geschrieben Funktionen etc. erst zur Laufzeit an.

Aber so mache ich das im Moment und das klappt wunderbar.

[mkinzler]

Besser OleVariant.
Du könntest auch die passenden Wrapper für Office2000 installieren. du scheinst die für OfficeXP gewählt zu haben

[Errraddicator]

Echt?
Ok, werde ich demnächst dann wohl berücksichtigen.

Was hat das denn fürn Sinn wenn ich fragen darf? :)
Bzw. wo is der Unterschied zwischen Variant und OleVariant?

[Andreas Leix]

Ich probier´s jetzt gerade ohne die fix gebundenen Typen TExcel, Tworkbook...,
sondern mit mit OLEVariant.
Ich komm dabei ein bisschen weiter, allerdings muß ich erst verschiedene Stellen,
wo ich die TExcelApplication und TWorksheetetc verwendet habe umändern.

Ein anderes Package einzubinden bringt nichts !!
Ich will die Software weitergeben und
weiss zur Compile-Zeit ja nicht,
welches Office auf dem Ziel-Rechner installiert ist.

Gruß
Andreas

[mkinzler]

OleVariant ist ein COM-Typ ist zwar momentan dasselbe könnte sicgh aber ändern.

Zitat:

Ein anderes Package einzubinden bringt nichts !!
Ich will die Software weitergeben und
weiss zur Compile-Zeit ja nicht,
welches Office auf dem Ziel-Rechner installiert ist.

Dann nimm trotzdem das von Office2000. das funktioniert dann mit den neuren auch. Umgekehrt, wie du siehst, nicht.

[sx2008]

Ich würde die frühe Bindung empfehlen und bei Problemen kurzzeitig auf die späte Bindung umschalten:

Delphi-Quellcode:

uses ExcelXP;
...
var Excel  : TExcelApplication;
    WB     : _WorkBook;
    x : OleVariant;
...
  x := Excel.Workbooks.Open(strDokument);
  // man kann hier sogar benannte Parameter verwenden.
  // das erhöht die Lesbarkeit des Code und man erspart sich die "EmptyParam"-Orgie
  x := Excel.Workbooks.Open(FileName:=strDokument);  // "FileName" ist der Parametername

  // zur Sicherheit prüfen, dass auch wirklich ein Dispatch-Interface vorliegt:
  if VarType(x) <> varDispatch then
     raise Exception.Create('Problem bei Ansteuerung von Excel');

  // und jetzt wieder zurück zur frühen Bindung
  WB := IDispatch(x) as _WorkBook;

  // jetzt gibt es 2 Referenzen auf das Workbook-Objekt
  // wer mag, kann jetzt die Referenz auf IDispatch-Interface freigeben
  x := Unassigned;

Mit diesem Trick kann man das Beste aus beiden Welten (frühe und späte Bindung) vereinen.

[Andreas Leix]

Hallo,

ich wußte nicht, dass man mit Varianten solche "Schhweinereien" machen kann;
also Methoden aufrufen, die man eigentlich nicht kennt, ohne fixe Anzahl von Parametern etc...

Also erstmal vielen Dank an Euch !!

Jetzt hab ich aber dennoch ein paar Anmerkungen/ Fragen :

Folgender Code läßt sich nicht compilieren:

Zitat:

uses ExcelXP;
...
var Excel : TExcelApplication;
WB : _WorkBook;
x : OleVariant;
...
x := Excel.Workbooks.Open(strDokument);

das geht nur , wenn ich

Delphi-Quellcode:

var Excel : OleVariant ; 
    Excel := CreateOleObject('Excel.Application');
    x := Excel.Workbooks.Open(strDokument);
...

schreibe.
Aber, hab ich den Kern des Tipps richtig verstanden ?

Man kann Ole-Varianten typisierten Variablen zuweisen
und dann auf die Methoden zugreifen ?

Geht das auch umgekehrt ?
also z.b. sowas :

Delphi-Quellcode:

var Excel: TExcelApplication ; 
    WB,X: OleVariant; 

begin
  Excel := TExcelApplication.Create ( nil ); 
  X:= Excel as OleVariant; 
  WB:= X.WorkBooks.Open ('Blubber'); 
...
end;

Und wie stehts dann mit dem Freigeben der Referenzen aus ?


Noch eine andere Frage.
Wenn ich nur mit Varianten arbeite,
dann brauch ich auch das Unit ExceXP oder ähnliches nicht aufnehmen, oder ?

Dann geschieht das Hochfahren/ Ansprechen von excel rein durch ?

Delphi-Quellcode:

MyExcel := CreateOleObject('Excel.Application');

Gruß vom lernenden
Andreas

[mkinzler]

Zitat:

Dann geschieht das Hochfahren/ Ansprechen von excel rein durch ?

Ja.

Zitat:

Man kann Ole-Varianten typisierten Variablen zuweisen
und dann auf die Methoden zugreifen ?

Ja. Die Aufrufe und Zugriffe werden zur Laufzeit an den entsprechenden COM-Server weitergeleitet. (späte Bindung)

Zitat:

Und wie stehts dann mit dem Freigeben der Referenzen aus ?

Man muss den ComServer(hier Excel) natürlich weieder beenden.

Zitat:

dann brauch ich auch das Unit ExceXP oder ähnliches nicht aufnehmen, oder ?

Nein.

[sx2008]

Hoppla, da hab ich nicht richtig aufgepasst (das kommt davon, wenn man Sourcecode ohne IDE eintippt).

Delphi-Quellcode:

uses ExcelXP;
...
var Excel : TExcelApplication;
WB : _WorkBook;
x, wbs : OleVariant;
...
wbs := Excel.Workbooks as IDispatch;
x := wbs.Open(strDokument);

Wenn du die Unit ExcelXP oder Excel97 nicht aufnimmst, dann bist du ja komplett bei der späten Bindung,
die zwar sehr flexibel aber auch langsam und nicht typsicher ist.
Für kleinere Aufgaben mit Excel geht das durchaus in Ordnung.
Bei grösseren Aufgaben ist es besser, wenn man nicht alles über OleVariant (und IDispatch-Schnittstellen) abwickelt.

[Andreas Leix]

Ok,jetzt habe ich einiges verstanden.

Jetzt komm ich weiter.

Also euch allen nochmal vielen Dank!

Gruß
Andreas