Type mit in andere Unit durchreichen...?

[Tonic1024]

Hi...

Ich hab wieder einmal ein Problem, bei dem es mir schwer fällt es in Worte zu fassen... Ist auch kein richtiges Problem, mehr eine "Unschönheit"

Ich habe eine Klasse entwickelt, die einen (evtl bald mehrere) Thread (TThread) benutzt. Ich brauche dafür nen selbstgebastelte Typ, den ich um ihn "quasiglobal" zu nutzen, in eine Extra-Unit gepackt habe.

Delphi-Quellcode:

unit ModemStuff;  // Aussagekräftigen Namen ausdenken... <!>

interface

type TModemResult = (mrNIL, mrError, mrOkay, mrPrompt, mrTimeOut);
{..}

implementation
{..}

end.

"ModemStuff" ist in den Uses-Klauseln der Thread-Units und der Klassen-Unit aufgeführt. Wenn ich in einem Programm nun diese Klasse verwenden will, muss ich in die Uses-Klauses des Programms sowohl die Klassen- als auch die Typen-Unit aufführen. Macht ansich nix, ich möchte aber den zukünftigen Usern dieser Unit aber keine potentiellen Fehlerquellen einbauen. Aus Gründen der Übersicht will ich aber auch nicht den ganzen quatsch in eine Unit kloppen.

Gibts da ne Lösung? Eine "schöne" Lösung?

MfG

Toni

[Flocke]

(ungetestet)

Delphi-Quellcode:

unit ThreadStuff;

uses
  ModemStuff;

type
  TModemResult := ModemStuff.TModemResult;

[Tonic1024]

Gute Idee...

Hatte ich aber auch schon. Da bewirkt das TModemResult zwar bekannt ist, nicht jedoch mrOkay... Irgendwie verwirrend...


[Edit] Mit "=" statt ":=" probiert...[/Edit]

[NicoDE]

Zitat von Tonic1024:

Gibts da ne Lösung? Eine "schöne" Lösung?

'Schön' wird schwierig...
Die Definitionen würden sich dann in zwei Namensräumen befinden. Die Delphi Language bietet aber kein Sprachelement um Typdeklarationen in andere Namensräume zu übernehmen. Eine Lösung könnte auf Includes basieren (was nicht 'schön' ist ).

[Tonic1024]

Ja, soweit war ich auch schon... Den Gedanken hab ich ansich schon in dem Moment verworfen als er mir kam....

[NicoDE]

Zitat von Tonic1024:

Ja, soweit war ich auch schon... Den Gedanken hab ich ansich schon in dem Moment verworfen als er mir kam....

Weise Entscheidung
Sowas kann 'unschöne' Ausmaße annehmen... habe mal ein altes Test-Template herausgesucht:

Delphi-Quellcode:

{$ifndef read_implementation}
  {$ifndef read_interface}

unit Unit1;

interface

//
// Interface uses here
// (must also use all units which are required by the units included below)
//

  {$endif !read_interface}
  {$ifndef included_interface_UNIT1}
  {$define included_interface_UNIT1}
    {$ifndef read_interface}
    {$define read_interface}
    {$define read_interface_UNIT1}
    {$endif !read_interface}

//
// Interface includes here
// (included units must support read_interface/read_implementation defines)
//

    {$ifdef read_interface_UNIT1}
    {$undef read_interface_UNIT1}
    {$undef read_interface}
    {$endif read_interface_UNIT1}

//
// Interface here
//

  {$endif !included_interface_UNIT1}
  {$ifndef read_interface}

implementation

//
// Implementation uses here
// (must also use all units which are required by the units included below)
//

  {$endif !read_interface}
{$endif !read_implementation}
{$ifndef read_interface}
  {$ifndef included_implementation_UNIT1}
  {$define included_implementation_UNIT1}
    {$ifndef read_implementation}
    {$define read_implementation}
    {$define read_implementation_UNIT1}
    {$endif !read_implementation}

//
// Implementation includes here
// (included units must support read_interface/read_implementation defines)
//

    {$ifdef read_implementation_UNIT1}
    {$undef read_implementation_UNIT1}
    {$undef read_implementation}
    {$endif read_implementation_UNIT1}

//
// Implementation here
//

  {$endif !included_implementation_UNIT1}
  {$ifndef read_implementation}
    {$warnings off}  // [Warning]: Text after final 'END.' - ignored by compiler
end.
  {$endif !read_implementation}
{$endif !read_interface}

(nicht unbedingt zur Nachahmung empfohlen - dann kann man auch gleich in C programmieren )

[himitsu]

Eventuell ja so?
(hab bisher auch noch keine Konstanten/Variablen weitergegeben -.-'')
Aber das mit dem Type ist schon richtig so (es funktioniert zumindestens ... und natürlich mit =, da es ja um 'ner Typenzuweisung geht)

Delphi-Quellcode:

unit ThreadStuff;

uses
  ModemStuff;

type
  TModemResult = ModemStuff.TModemResult;

const
  mrNILmrError = ModemStuff.mrNILmrError;
  mrOkay       = ModemStuff.mrOkay;
  mrPrompt     = ModemStuff.mrPrompt;
  mrTimeOut    = ModemStuff.mrTimeOut;

Am Sichersten wäre es aber bestimmt so.

Delphi-Quellcode:

unit ThreadStuff;

uses
  ModemStuff;

type
  TModemResult = ModemStuff.TModemResult;

const
  mrNILmrError = TModemResult(ModemStuff.mrNILmrError);
  mrOkay       = TModemResult(ModemStuff.mrOkay);
  mrPrompt     = TModemResult(ModemStuff.mrPrompt);
  mrTimeOut    = TModemResult(ModemStuff.mrTimeOut);

PS: hab Derzeit kein Delphi, also vollkommen ungetestet.

[Tonic1024]

Hi Himitsu...

Schöne Lösung, nur leider völlig an meinem Problem vorbei Dann müsste ja de User, der garnicht weiss/ nicht wissen muss wie die Modem-Komponente arbeitet auch den const-teil in seinem Code eingeben, was ich ja verhindern will. Der soll ja garnichts machen...


Aber... *grübel*

Wenn ich die Type in der "Haupt-Unit" mit der Klasse für den Userzurgiff definiere und nur intern deine Lösung verwende... *HektischPapierUndBleistiftRauskram* - Werd ich ausprobieren... Danke.


Toni

[Schwedenbitter]

Zitat von Tonic1024:

Hi Himitsu...
Aber... *grübel*

Wenn ich die Type in der "Haupt-Unit" mit der Klasse für den Userzurgiff definiere und nur intern deine Lösung verwende... *HektischPapierUndBleistiftRauskram* - Werd ich ausprobieren... Danke.

Gibt es denn schon eine Lösung für das Problem?
Diese würde mich wirklich brennend interessieren.

Gruß, Alex

[Thomas_K]

Hier ist auf die Schnelle mein Lösungsvorschlag:

Die Unit der den Type beinhält, aber in einer Klasse versteckt.

Code:

unit UnitTypeClass;

interface

type
  TTypeClass = class
    type
      TModemResult = (mrNIL, mrError, mrOkay, mrPrompt, mrTimeOut);
  end;

implementation

end.

Hier die Unit mit der Klasse, die nur der Anwender nutzen soll.

Code:

unit UnitUserClass;

interface

uses
  UnitTypeClass;

type
  TUserClass = class(TTypeClass)
  private
    FModemResult: TTypeClass.TModemResult;
  public
    property ModemResult: TTypeClass.TModemResult read FModemResult write FModemResult;
  end;

implementation

end.

Und schlussendlich das Anwenden der User Klasse.

Code:

uses
  UnitUserClass;

procedure TMainForm.ButtonTestClick(Sender: TObject);
var
  UserClass: TUserClass;
begin
  UserClass := TUserClass.Create;
  try
    UserClass.ModemResult := TUserClass.TModemResult.mrNIL;
  finally
    UserClass.Free;
  end;
end;

Das Ganze noch einmal als fertiges Projekt zum Runterladen.