Type mit in andere Unit durchreichen...?

[DeddyH]

Kannte denn Delphi 2006 bzw. Turbo Delphi schon Nested Types?

[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...

[Thomas_K]

Zitat von DeddyH:

Kannte denn Delphi 2006 bzw. Turbo Delphi schon Nested Types?

Ich verwende Nested Types mindesten seit Delphi 6, ganz unproblematisch ist aber die Sache nicht, in neueren Delphi-Versionen lässt sich damit relativ einfach die Quellcode-Vervollständigung außer Kraft setzen. Dann muss man halt etwas mit zusätzlichen und eigentlich überflüssigen Klassen direktiven(protected,private,public) experimentieren, bzw. andere Kopfstände machen.

[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.

[Stevie]

Zitat von Thomas_K:

Ich verwende Nested Types mindesten seit Delphi 6

Garantiert nicht, die kamen erst nach Delphi 7.

[Thomas_K]

Zitat von Stevie:

Zitat von Thomas_K:

Ich verwende Nested Types mindesten seit Delphi 6

Garantiert nicht, die kamen erst nach Delphi 7.

Erwischt, ich habe unter Delphi 6 nur ein paar Records innerhalb einer Klasse erzeugt. Für Records brauch man nicht unbedingt type verwenden, solange man es nur einmal innerhalb eines Objektes benötigt.

[himitsu]

Zitat von Thomas_K:

Erwischt, ich habe unter Delphi 6 nur ein paar Records innerhalb einer Klasse erzeugt. Für Records brauch man nicht unbedingt type verwenden, solange man es nur einmal innerhalb eines Objektes benötigt.

Record-Variablen oder wirklich Typen?

Wie bereits erwähnt, dürfte der Typ nicht gehen.

Delphi-Quellcode:

type
  TMyRecord = record
    i: Integer;
    S: string;
  end;

  TMyClass = class
  public type
    TMyInnerRecord = record
      i: Integer;
      S: string;
    end;
  public
    FFieldInner: TMyRecord;
    FFieldOuter: TMyInnerRecord;
    FFieldDirect: record
      i: Integer;
      S: string;
    end;
  end;

var
  MyGlobalVarInner: TMyRecord;
  MyGlobalVarOuter: TMyClass.TMyInnerRecord;
  MyGlobalVarDirect: record
    i: Integer;
    S: string;
  end;

Die Inlinedeklaration geht schon lange, sonst müsste man auch bei jedem array of ... das erstmal als eigenen Typen deklarieren, bevor man damit eine Variable definieren kann.

[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