Guten Tag,
Ich habe neuerdings Ole-Objekte "verwendet" ohne das ich im geringsten eine Ahnung habe, was ich da wirklich gemacht habe (im Grunde habe ich da einfach vorgefertigten, alten Code angepasst und wieder funktionsfähig gemacht).

Ich habe bereits ein bisschen recherchiert und Sachen wie Ole-Automation (Beispiele mit Word Dokumenten) gefunden. Jedoch sind die Artikel/Tutorials dazu nicht wirklich aufklärend.

Was ich bisher so aus eigener Interpretation verstanden habe..:
1. man kann am System (OS) Objekte (Klassen/Funktionen?) registrieren
2. Anwendungen können über CreateOleObject (mehr?) diese Objekte&/Methoden importieren und verwenden

Meine Fragen nun dazu:
- wie funktioniert 1, wie bewerkstellige ich das selber?
- wo schlage ich für 2. nach um rauszufinden, was so alles ein Objekt drauf hat (Methoden? CLSID?)

Ich stell mir das momentan so ähnlich wie das Verwenden von Win-API Funktionen vor. Gibt es für OLE Objekte, die z.B. vom BS bereitgestellt werden, eine Doku/Spezifikation usw.?

Ich wünsche euch frohe Weihnachten und vorzeitig einen guten Rutsch ins neue Jahr.

Zitat von Aphton:

- wie funktioniert 1, wie bewerkstellige ich das selber?

Die nötigen Infos werden in die Registry geschrieben
Selbst kannst du das machen indem du bei Delphi die entsprechenden Wizards über "Neu" bemühst.

Zitat von Aphton:

- wo schlage ich für 2. nach um rauszufinden, was so alles ein Objekt drauf hat (Methoden? CLSID?)

In der sogenannten Typbibliothek steht beschrieben welche Methoden und Interfaces es gibt.
Microsoft stellt mit OleView ein Tool bereit mit der man die registrieten Anwendungen durchsuchen kann.
Aber jeder Hersteller sollte normalerweise eine Schnittstellenbeschreibung liefern.

Wo ist die Frage zu den Variants?

Variant ist ein Typ, wie z.B. Integer, allerdings kann der mehrere verschiedene Werte enthalten, also man kann da Strings, Integer, Interfaces, Arrays usw. dort reipacken.



Selbst genutzt hab ich das noch nicht, aber es gibt bestimmt Tutorials dafür.
Im Prinzip erstellt man ein Interface, welches, bzw. dessen DLL bei Windows registriert wird.
Und das dann von anderen Programmen abgefragt werden kann.
z.B. die Interfaces des MS-XML-DOM (IXMLDocument usw.)

https://www.google.de/search?q=windows+dll+registrieren
über Delphi DLL erstellen Regsvr32 oder sonstwie, sollten sich Tutorials finden lassen

Danke.

Zu Variants - meistens wird das in Verbindung mit Ole Objekten verwendet; ich wusste z.B. nicht, dass Variants wie Klasseninstanzen behandelt und beliebige (Ole) Methoden darüber aufgerufen werden können.

Ich werde weiter recherchieren, bis ich eine kleine Demo dazu schreibe, und ab und zu hier nachkucken, sofern etwas neues hinzukommt.

In Delphi wird der Vaiant mehr wie ein Record verwaltet.

Du kannst das mit den Record Operatoren vergleichen, wo in dem Variant schon automatische Konvertierungen integriert sind.
Aber eigentlich ist das ein Windows-Typ, ähnlich dem WideString, welcher im Delphi entsprechend weggekapselt ist.

zusammenfalten · markieren

Delphi-Quellcode:

var
  X: Variant;

X := 123;
ShowMessage(IntToStr(X));
ShowMessage(X);

X := 'abc';
ShowMessage(X);

X := '789';
ShowMessage(X);
ShowMessage(IntToStr(X + 210));

Die Unit Variants wäre noch interessant, wo viele Funktionen drin sind, um die Typen manuell umzuwandeln oder um zu prüfen welcher Typ grade im Variant steckt.
Und falls man selber den Variant erweitern will, dann könnte man beim TVariantManager weiter suchen.

Bissl was zum Aufbau, falls dich das interessiert (system.pas):

zusammenfalten · markieren

Delphi-Quellcode:

  varEmpty = $0000; { vt_empty        0 }
  varNull = $0001; { vt_null         1 }
  varSmallint = $0002; { vt_i2           2 }
  varInteger = $0003; { vt_i4           3 }
  varSingle = $0004; { vt_r4           4 }
  varDouble = $0005; { vt_r8           5 }
  varCurrency = $0006; { vt_cy           6 }
  varDate = $0007; { vt_date         7 }
  varOleStr = $0008; { vt_bstr         8 }
  varDispatch = $0009; { vt_dispatch     9 }
  varError = $000A; { vt_error       10 }
  varBoolean = $000B; { vt_bool        11 }
  varVariant = $000C; { vt_variant     12 }
  varUnknown = $000D; { vt_unknown     13 }
//varDecimal = $000E; { vt_decimal 14 } {UNSUPPORTED as of v6.x code base}
//varUndef0F = $000F; { undefined 15 } {UNSUPPORTED per Microsoft}
  varShortInt = $0010; { vt_i1          16 }
  varByte = $0011; { vt_ui1         17 }
  varWord = $0012; { vt_ui2         18 }
  varLongWord = $0013; { vt_ui4         19 }
  varInt64 = $0014; { vt_i8          20 }
  varUInt64 = $0015; { vt_ui8         21 }
  varRecord = $0024; { VT_RECORD      36 }
{  if adding new items, update Variants' varLast, BaseTypeMap and OpTypeMap }

  varStrArg = $0048; { vt_clsid        72 }
  varObject = $0049; {                 73 }
  varUStrArg = $004A; {                 74 }
  varString = $0100; { Pascal string  256 } {not OLE compatible }
  varAny = $0101; { Corba any      257 } {not OLE compatible }
  varUString = $0102; { Unicode string 258 } {not OLE compatible }
  // custom types range from $110 (272) to $7FF (2047)

  varTypeMask = $0FFF;
  varArray = $2000;
  varByRef = $4000;

  TVarData = packed record
    case Integer of
      0: (VType: TVarType;
          case Integer of
            0: (Reserved1: Word;
                case Integer of
                  0: (Reserved2, Reserved3: Word;
                      case Integer of
                        varSmallInt: (VSmallInt: SmallInt);
                        varInteger: (VInteger: Integer);
                        varSingle: (VSingle: Single);
                        varDouble: (VDouble: Double);
                        varCurrency: (VCurrency: Currency);
                        varDate: (VDate: TDateTime);
                        varOleStr: (VOleStr: PWideChar);
                        varDispatch: (VDispatch: Pointer);
                        varError: (VError: HRESULT);
                        varBoolean: (VBoolean: WordBool);
                        varUnknown: (VUnknown: Pointer);
                        varShortInt: (VShortInt: ShortInt);
                        varByte: (VByte: Byte);
                        varWord: (VWord: Word);
                        varLongWord: (VLongWord: LongWord);
                        varInt64: (VInt64: Int64);
                        varUInt64: (VUInt64: UInt64);
                        varString: (VString: Pointer);
                        varAny: (VAny: Pointer);
                        varArray: (VArray: PVarArray);
                        varByRef: (VPointer: Pointer);
                        varUString: (VUString: Pointer);
                        varRecord: (VRecord: TVarRecord);
                        //$ffff: (VLargest: TLargestVarData);
                     );
                  1: (VLongs: array[0..{$IFDEF CPUX64}4{$ELSE}2{$ENDIF}] of LongInt);
               );
            2: (VWords: array [0..{$IFDEF CPUX64}10{$ELSE}6{$ENDIF}] of Word);
            3: (VBytes: array [0..{$IFDEF CPUX64}21{$ELSE}13{$ENDIF}] of Byte);
          );
      1: (RawData: array [0..{$IFDEF CPUX64}5{$ELSE}3{$ENDIF}] of LongInt);
  end;

Zitat von Aphton:

Zu Variants - meistens wird das in Verbindung mit Ole Objekten verwendet; ich wusste z.B. nicht, dass Variants wie Klasseninstanzen behandelt und beliebige (Ole) Methoden darüber aufgerufen werden können.

Das ist nur bedingt richtig. Ein Variant kann verschiedene Datentypen enthalten. Integer, Double, Boolean usw. aber unter anderem auch Objekte und Interfaces. Wenn ein OLE-Interface (genauer ein IDispatch) in einem Variant gespeichert ist, dann kann ich auf die Interface-Methoden einfach durch die Punkt-Notation zugreifen. Allerdings wird dabei erst zur Laufzeit geprüft, ob die entsprechende Methode auch tatsächlich existiert.

Der folgende Code wird also vom Compiler durchgelassen, führt aber zu einem Laufzeitfehler:

markieren

Delphi-Quellcode:

var
  V: Variant;
begin
  V := 1;
  V.Hurz;
end;

Das ist alles echt aufklärend! Danke soweit.

Wie kommts, dass ich soetwas praktische nie gebraucht habe xD
Man lernt nie aus.

Ich macht dann mal weiter mit dem Einlesen (regsvr, clsids)..