Zitat von
Elvis:
[1]und das willst du weil platte C-kompatible DLLs bestenfalls als menschenverachtende Folter in Den Haag verhandelt werden sollten
Genau das hatte ich vor. Nun stolpere ich aber alle Nase lang über Interfaces und bekomme ein schlechtes Gewissen.
(Auch wenn ich die Idee mit einem generischen Pointer und einer einfach Konstante, damit die
DLL weiß, was da für ein Typ hinter dem Pointer steckt, reizvoll finde..
).
Ich raffe irgendwie den C#-Teil noch nicht so ganz. Nehmen wir mal folgendes Beispiel:
Das Programm soll modular aufgebaut sein. Das heißt, ich soll nach belieben Plugins hinzufügen und wegnehmen können. Nehmen wir mal an, dass das Programm eine Klasse hat, die so aufgebaut ist:
Delphi-Quellcode:
Type
Tst_mmclass =
class
private
(* Path of the file being played *)
fMediaFile : AnsiString;
(* Handle of the current audio stream *)
fCurrentStream : HSTREAM;
(* Handle of the application *)
fAppHandle : HWND;
(* Stream is playing *)
fStreamIsPlaying: Boolean;
(* We need the Plugin Observer, so this class can adress plugins *)
fPluginObserver: TPluginObserver;
(* Assign Channel to new Media File *)
procedure NewMediaFile(
const Value: AnsiString);
procedure SetPluginObserver(
const Value: TPluginObserver);
public
property MediaFile : AnsiString
read fMediaFile
write NewMediaFile;
property AppHandle : HWND
read fAppHandle
write fAppHandle;
property CurrentStream : HSTREAM
read fCurrentStream
write fCurrentStream;
property StreamIsPlaying : Boolean
read fStreamIsPlaying
write fStreamIsPlaying;
property PluginObserver : TPluginObserver
read fPluginObserver
write SetPluginObserver;
(* Playback Control *)
procedure Play;
procedure Pause;
procedure NextTrack;
procedure PrevTrack;
(* Initialization of Bass.dll *)
procedure InitBass(Path: AnsiString);
(* Deinitialization of Bass.dll *)
procedure DeInitBass;
(* Con- & Destructor *)
Constructor Create;
Destructor Destroy;
override;
end;
Ferner gibt es eine Klasse, TPluginObserver, die eine Liste aller geladenen Plugins verwaltet. Außerdem soll sie eigentlich auch die Aufrufe der Plugins und die Nachrichten der Plugins an die Anwendung verwalten. (Ja, mit meinem System hätte ich mit SendMessage Application-interne Nachrichten verschickt, mit entsprechenden Pointer garniert.) Meine Hoffnung an Interfaces ist, dass ich das gar nicht machen muss.
Angenommen, ich möchte jetzt, dass ein Plugin eine Playlist bereitstellt. Wie würde jetzt ein Beispiel mit Interfaces aussehen, in dem das Plugin dem Hauptprogramm den Dateipfad übergibt (soll in die Property "MediaFile" geschrieben werden) und anschließend die Prozedur "Play" ausführt. Und wie würde man in die andere Richtung kommunizieren? Denn wenn der Anwender auf "Next Track" klickt, muss ich dem Plugin ja mitteilen können, dass ich jetzt den nächsten Eintrag aus der Liste brauche...
Oder sollte ich zur Kommunikation meine Observer-Klasse ausbauen?
Würde mich über ein Beispiel zu diesem Anwendungsfall freuen, ich stehe gerade etwas auf dem Schlauch...
