Type mit in andere Unit durchreichen...?

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

[DeddyH]

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

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

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

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.