Type mit in andere Unit durchreichen...?

[Dejan Vu]

Also ich finde das verwirrend. Da wird ein Datentyp deklariert, den man aber nicht verwenden soll, sondern einen anderen, der aber genau das gleiche ist. Wenn man das aber doch machen sollte, funktioniert das dann doch gar nicht mehr, oder irre ich mich? So wie der Threadersteller von 9 Jahren meinte, er möchte keine Fehlerquellen einbauen, geht es doch gar nicht. Man kann doch eher so Fehlerquellen einbauen (einfach beide Units importieren und versehentlich den anderen Datentyp verwenden).

Was sollen diese Klimmzüge? Wenn der Typ separat deklariert ist, dann verwende ich eben diese Unit explizit. Oder ich mappe sie explizit, aber so verstecken? Nur weil ich nur eine Unit importieren will? Ich könnte auch einfach alle Threads in eine Unit schmeißen, wenn es also darum ginge, wäre das die einfachste Art. Macht die VCL ja auch so...

[p80286]

Zitat von Dejan Vu:

Also ich finde das verwirrend. Da wird ein Datentyp deklariert, den man aber nicht verwenden soll, sondern einen anderen, ...

Wenn ich das richtig verstanden habe, geht es darum eine Unit mit Typ (und anderen) Deklarationen für den Benutzer "unsichtbar" einzubinden. Hätte ich auch gerne, scheint aber nicht machbar zu sein.

Gruß
K-H

[Sir Rufo]

Geht doch einwandfrei ... ob es sinnvoll ist, steht ja auf einem anderen Blatt

Delphi-Quellcode:

unit MyLib.Types;

interface

// Nicht notwending, aber nach dem Durchreichen muss eh mit TSomeType.stNothing gearbeitet werden.
{$SCOPEDENUMS ON}

type
  TSomeType = ( stNothing, stVery, stUseful );

implementation

end.

Delphi-Quellcode:

unit MyLib.Core;

interface

uses
  MyLib.Types;

type
  TMyCore = class
  public
    constructor Create( AType: TSomeType );
  end;

implementation

{ TMyCore }

constructor TMyCore.Create( AType: TSomeType );
begin
  inherited Create;

end;

end.

Zusammenfassen:

Delphi-Quellcode:

unit MyLib;

interface

uses
  MyLib.Types,
  MyLib.Core;

type
  TSomeType = MyLib.Types.TSomeType;
  TMyCore = MyLib.Core.TMyCore;

implementation

end.

Verwenden:

Delphi-Quellcode:

program dp_055615;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  MyLib in 'MyLib.pas';

procedure Main;
var
  LInstance: TMyCore;
begin
  LInstance := TMyCore.Create( TSomeType.stNothing );
  try

  finally
    LInstance.Free;
  end;
end;

begin
  try
    Main;
  except
    on E: Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

[Dejan Vu]

Zitat von Sir Rufo:

Geht doch einwandfrei ... ob es sinnvoll ist, steht ja auf einem anderen Blatt

Wie immer gut erklärt und durch den Einwurf 'ob es sinnvoll ist...' auch in der richtigen Ecke gelandet.

Es bleibt dabei (für mich): Will ich mir einen abbrechen, nur um ein glasklares und stringentes 'uses' zu unterbinden? Verzichte ich auf Messer, Gabel und Löffel, damit ich mir noch mit -der Einfachheit wegen- Gameffel hantieren muss? Ist das wirklich einfacher? Muss jeder selbst entscheiden.

[Stevie]

Zitat von Dejan Vu:

Zitat von Sir Rufo:

Geht doch einwandfrei ... ob es sinnvoll ist, steht ja auf einem anderen Blatt

Wie immer gut erklärt und durch den Einwurf 'ob es sinnvoll ist...' auch in der richtigen Ecke gelandet.

Es bleibt dabei (für mich): Will ich mir einen abbrechen, nur um ein glasklares und stringentes 'uses' zu unterbinden? Verzichte ich auf Messer, Gabel und Löffel, damit ich mir noch mit -der Einfachheit wegen- Gameffel hantieren muss? Ist das wirklich einfacher? Muss jeder selbst entscheiden.

Ich finde das teilweise schon praktisch. Gerade unter Berücksichtigung, dass es in Delphi keine richtigen Namespaces gibt. Da kann ich nich einfach uses MeineLib schreiben sondern muss die drölfzig Units, aus denen ich was brauche einzeln "usen". Natürlich nur ein stümperhafter Behelf aus Mangel an Alternativen

[Dejan Vu]

Daran hab ich auch gedacht ('Namespaces'), aber mir dann gesagt: Wenn man schon bei Delphi ist, dann soll man imho die Sprache doch so nutzen, wie sie gedacht ist... Also 'Units' als Vorgänger der Namespaces mit allen Eigenheiten, so wie hier. Da hat man dann eben nicht drölfzig (oder sogar einundrölfzig!) Units, sondern genau: 2 (Typ und Klassen).

Andere Möglichkeit: Eine Unit für den Typen, Interfaces der Threads und eine Factory. Threadklassen melden sich in der Factory an. Anwender bindet nur die Typ-Unit ein und holt sich die Instanzen über die Factory.