Automatisierung ist eine Methode zur automatischen Steuerung einer Anwendung innerhalb einer anderen Anwendung, wie beispielsweise der folgende Code.
PROzedur CreateNewWord;
var
WordObj: Variante;
beginnen
WordObj := CreateOleObject('Word.Basic'); {Diese Funktion ist in der ComObj-Einheit deklariert}
WordObj.AppShow;
WordObj.FileNew;
Ende;
Dieser Code öffnet WORD und erstellt automatisch ein neues Dokument (vorausgesetzt ist natürlich, dass WORD auf Ihrem Computer installiert ist). Dies scheint eine sehr interessante und sehr nützliche Funktion zu sein. Wie kann unser Programm also auch ähnliche Automatisierungsfunktionen wie WORD haben? Erlauben Sie Programmen, die in einer anderen Sprache entwickelt wurden, unsere Programme zu automatisieren. Es ist sehr einfach, dies mit DELPHI zu implementieren.
In diesem Artikel wird anhand von Beispielen Schritt für Schritt erklärt, wie Sie einen einfachen Automatisierungsserver entwickeln.
Erstellen Sie eine neue normale Anwendung und speichern Sie das Projekt als AutoSrv.bpr. Platzieren Sie ein Bearbeitungssteuerelement im Hauptformular und speichern Sie es als MainForm.pas. Hier möchten wir den Fenstertitel, die Formularfarbe und den Text hinzufügen Bearbeiten Sie das Steuerelement (dies implementiert natürlich nur sehr wenige Funktionen, aber es reicht aus, um zu erklären, wie man ein automatisiertes Serverprogramm entwickelt), und fügen Sie den folgenden Code zum Hauptfenster hinzu: (Hinweis: Bitte fügen Sie die Deklarationen dieser Funktionen und Prozeduren zu TForm1 hinzu allein öffentlicher Bereich)
Funktion TForm1.GetCaption: string;
beginnen
Ergebnis := Self.Caption;
Ende;
procedure TForm1.SetCaption(ACaption: string);
beginnen
Self.Caption := ACaption;
Ende;
procedure TForm1.SetColor(AColor: TColor);
beginnen
Self.Color := AColor;
Ende;
procedure TForm1.SetEditText(AText: string);
beginnen
Self.Edit1.Text := AText;
Ende;
Dann fügen wir diesem Programm Automatisierungsfunktionen hinzu, klicken auf die Schaltfläche „Neue Elemente“, klicken im Popup-Fenster „Neue Elemente“ auf die Registerkarte „ActiveX“, wählen „Automatisierungsobjekt“ aus, klicken auf die Schaltfläche „OK“ und geben im Popup-Automatisierungsobjekt-Assistenten den CoClass-Namen ein Fenster MyAutoSrv generiert Delphi automatisch eine AutoSrv_TLB.pas-Datei (Klassenbibliothek) und eine Einheit, die die Klassenbibliotheksschnittstellenklasse implementiert, und speichert diese neue Einheit als AutoSrvClass.pas
Nachdem dieses Programm nun zu einem automatisierten Server geworden ist, fügen wir ihm automatisierte Schnittstellenfunktionen hinzu:
(1) Klicken Sie auf das Menü „Ansicht->Typbibliothek“, wählen Sie die IMyAutoSrv-Schnittstelle im Typbibliothekseditor aus, klicken Sie auf „Neue Eigenschaft“, wählen Sie die Eigenschaft „Lesen|Schreiben“ aus, nennen Sie sie „Caption“ und legen Sie den Typ auf „BSTR“ fest.
(2) Klicken Sie auf Neue Methode, nennen Sie sie SetColor, klicken Sie rechts auf die Registerkarte Parameter, klicken Sie auf HINZUFÜGEN, um der neu hinzugefügten Schnittstellenfunktion einen Parameter hinzuzufügen, legen Sie den Parameternamen auf AColor und den Parametertyp auf OLE_COLOR fest.
(3) Klicken Sie erneut auf „Neue Methode“, nennen Sie sie „SetEditText“, fügen Sie mithilfe der oben genannten Methode einen Parameter hinzu, setzen Sie den Parameternamen auf „AText“ und den Parametertyp auf „BSTR“.
Fügen Sie abschließend den Implementierungscode der Schnittstellenfunktion hinzu und schon ist alles in Ordnung:
Fügen Sie MainForm im Abschnitt „Uses“ von AutoSrvClass.pas hinzu und ändern Sie den Code in den folgenden Code.
Einheit AutoSrvClass;
{$WARN SYMBOL_PLATFORM AUS}
Schnittstelle
verwendet
ComObj, ActiveX, AutoSrv_TLB, StdVcl, MainForm;
Typ
TMyAutoSrv = class(TAutoObject, IMyAutoSrv)
geschützt
Funktion Get_Caption: WideString;
procedure Set_Caption(const Value: WideString);
procedure SetColor(AColor: OLE_COLOR);
procedure SetEditText(const AText: WideString);
Ende;
Durchführung
verwendet ComServ;
Funktion TMyAutoSrv.Get_Caption: WideString;
beginnen
Ergebnis := Form1.GetCaption;
Ende;
procedure TMyAutoSrv.Set_Caption(const Value: WideString);
beginnen
Form1.SetCaption(Value);
Ende;
procedure TMyAutoSrv.SetColor(AColor: OLE_COLOR);
beginnen
Form1.SetColor(AColor);
Ende;
procedure TMyAutoSrv.SetEditText(const AText: WideString);
beginnen
Form1.SetEditText(AText);
Ende;
Initialisierung
TAutoObjectFactory.Create(ComServer, TMyAutoSrv, Class_MyAutoSrv,
ciMultiInstance, tmApartment);
Ende.
Führen Sie dieses Programm einmal aus und es wird automatisch als Automatisierungsserver registriert. Die zugehörigen Registrierungsinformationen finden Sie unter dem Primärschlüssel HKEY_CLASSES_ROOT in der Registrierung.
Das Obige zeigt, wie man einen Automatisierungsserver entwickelt, den wir hier nennen werden.
Erstellen Sie ein neues Programm, fügen Sie eine Schaltfläche hinzu und deklarieren Sie eine Variant-Variable in ihrem VAR-Bereich: AutoSrv: Variante
Fügen Sie dann den folgenden Code zu Button1 hinzu.
procedure TForm1.Button1Click(Sender: TObject);
beginnen
AutoSrv := CreateOleObject('AutoSrv.MyAutoSrv'); {Diese Zeichenfolge ist der Projektname des Automatisierungsservers plus CoClass-Name}
Self.Caption := AutoSrv.Caption;
AutoSrv.Caption := 'HEHE';
AutoSrv.SetColor(CLRed);
AutoSrv.SetEditText('HAHA');
Ende;
Die CreateOleObject-Funktion gibt eine Schnittstelle vom Typ IDispatch zurück. Es ist die IDispatch-Schnittstelle, die es unserem Programm ermöglicht, späte Verbindungen zu Aufrufen der automatisierten Serverschnittstelle herzustellen. Wenn wir oben beispielsweise eine AutoSrv.Hello hinzufügen, kann das Programm auch kompiliert werden Bei der Ausführung tritt jedoch ein Fehler auf. Die Ausführungseffizienz bei der Verwendung von Variant ist langsamer als bei der direkten Verwendung der Schnittstellendeklaration.
Führen Sie es aus und klicken Sie auf die Schaltfläche. Sie können sehen, dass das automatisierte Serviceprogramm geladen ist und die Formularfarbe und die Zeichenfolge in EDIT1 gemäß unserem Code festgelegt sind. Haha, ist das sehr einfach?