Null als Property

[IntelliSoft]

Hallo
Zu aller erst, möchte ich HALLO sagen!
Ich bin neu in eurer Gemeinde & bin voller Vorfreude.

Eine kurze Vorstellung, vor der Frage, finde ich als angebracht.
Ich komme von Visual Basic. NET zu Delphi. Grund dafür ist, dass MS, Visual Basic fallen gelassen hat & nicht dieses umständliche C# lernen möchte...
Ich arbeite in VB.Net seit der ersten .NET Generation (also 2001) und davor auch schon mit einigen anderen Basic Sprachen.
Jetzt bin ich hier, bei Delphi angekommen & versuche die Handhabung so gut es geht im Selbststudium zu meistern.
Doch leider gibt es nicht auf alles eine schnelle & einfache Antwort - Deshalb hier zu meiner Frage:

In der .NET Welt gibt es Nullable(of ...).
Damit kann man Datentypen deklarieren, die keinen Wert aufweisen sollen.
Soweit ich das verstanden habe, kennt Delphi (im Moment) dieses Konzept nicht. Deshalb die Frage: Wie geht man in Delphi damit um?

Als kleines, praxisorientiertes Beispiel:


Ich habe 3 Properties:
Staerke1: Float
Staerke2: Float
Achse: 0..180

Jetzt ist es so, dass die Property Achse nur dann einen Wert haben darf, wenn Staerke2 <> 0 ist, wobei es "0" als Staerke2 gar nicht gibt...
Das heißt, die Rückgabe von Achse darf nur dann einen Wert haben (zwischen 0 und 180) wenn Staerke2 nicht "0" ist.
Wenn Staerke2 "0" wäre, dann darf die Achse keinen Rückgabewert haben & auch Staerke2 müsste "NIL" sein

Ich hoffe, das war logisch...

DANKE für Tips!

[mkinzler]

Mit Delphi 5 wirst Du da Probleme haben. In neueren Delphiversionen gibt es die Möglichkeit per generics:

Delphi-Quellcode:

unit Nullable;

interface

uses
  Classes, SysUtils;

type
  TNullable<T> = record
  private
    FHasValue: Boolean;
    FValue: T;
    function GetValue: T;
    procedure SetValue(AValue: T);
  public
    procedure Clear;
    property HasValue: Boolean read FHasValue;
    property Value: T read GetValue write SetValue;
    class operator Implicit(A: T): TNullable<T>;
    class operator Implicit(A: Pointer): TNullable<T>;
  end;

implementation

{ TNullable }

function TNullable<T>.GetValue: T;
begin
  if FHasValue then
     Result := FValue
  else
    raise Exception.Create('Variable has no value');
end;

procedure TNullable<T>.SetValue(AValue: T);
begin
  FValue := AValue;
  FHasValue := True;
end;

procedure TNullable<T>.Clear;
begin
  FHasValue := False;
end;

class operator TNullable<T>.Implicit(A: T): TNullable<T>;
begin
  Result.Value := A;
end;

class operator TNullable<T>.Implicit(A: Pointer): TNullable<T>;
begin
  if A = nil then Result.Clear
  else raise Exception.Create('Pointer value not allowed');
end;

end.

[IntelliSoft]

Hallo

1) Danke für die schnelle Antwort
2) Das mit Version 5 von Delphi hatte ich gar nicht eingestellt... -> Habe es aber geändert: Ich arbeite mit 10.3 Communitiy Edition
3) Das von Dir gezeigt Beispiel funktioniert aber erst ab 10.4, soweit ich da gelesen habe!?

DANKE

[IntelliSoft]

OH
Hab es gerade getestet, scheint auch super in der Version 10.3 zu funktionieren!

DANKE - Ich werde das mal testen!!!!

SUPER!

[mkinzler]

Sollte eigentlich mit allen Versionen mit Generics funktionieren. (ab D2009)

[himitsu]

Wollte Delphi nicht auch nativ Nullable-Typen demnächst eingebaut haben? (dachte da war mal was in 10.2/3/4 geplant)


Jetzt ab 10.4 würde die Initialisation des Managed-Records sich gut machen, um den Wert automatisch "sauber" zu haben.

[mkinzler]

Geplant war/ist viel ...

[Rolf Frei]

Ja da habe ich mich auch schon gefragt was daraus geworden ist. Das sollte doch glaube ich in 10.3 (oder sogar schon in 10.2.x) eingeführt werden und wurde dann kurzfristig wieder rausgenommen. Leider hat man seit da nichts mehr dazu gelesen. Mich würde schon auch interessieren wie es damit weiter geht oder ob das komplett gestorben ist. Hatte aber selber auch noch garnie den Bedarf dafür, weil man das auch anders lösen kann.

An den OP: Wieso definierst du denn nicht einfach, dass 0 kein gültiger Wert ist, also genau das was du ja schreibst. Wenn Stärke2 = 0 ist entspricht das deinem Null. Beim setzen des Property Achse prüfst du den Wert von Stärke2 und änderst den Wert von Achse (das Klassenfeld FAchse) nur wenn Stärke2 <> 0 ist. Mit einem SetAchse/GetAchse des Proberties kannst du das problemlos umsetzen. Die Achse initialiserst du natürlcih mit ienem ungültigen Wert wie z.B. -1, was dann für die Achse dem Null entsprechen würde.

Delphi-Quellcode:

type
  TMyObject = class
  private
    FAchse: Integer;
    FStaerke1,
    FStaerke2: Double;
    procedure SetAchse(AValue: Double);
    function GetAchse: Double;
  public
    constructor Create; virtual;
    property Achse: Double read GetAchse write SetAchse;
    property Staerke1: Double read FStaerke1 write FStaerke1;
    property Staerke2: Double read FStaerke2 write FStaerke2;
  end;

constructor TMyObject.Create;
begin
  FAchse := -1;
  // Staerke1 + 2 werden vom Compiler mit 0 initialisiert
end;

function TMyObject.GetAchse: Double;
begin
  if FStaerke2 <> 0 then
    Result := ....  // deine Achsenberechnung
  else
    Result = -1;  // oder eine Exception auslösen je nach Bedarf
end;

procedure TMyObject.SetAchse(AValue: Double);
begin
  // hier kanns du irgendwas machen, was beim setzen des Achse Properties passieren soll.
  // z.B. überprüfen ob der Wert einem gültigen Wert für Achse entspricht.
end;

[himitsu]

Single/Double/Float kennen als "Werte" auch NaN, Infinity und NegInfinity.

NaN (not a number) kann man hier als "NULL" (kein Wert / keine Zahl) verwenden.


Über die Fehlerbehandlung der FPU auch steuern, wie bei Berechnungen mit NaN umgegangen werden soll,
ansonsten vorher eben mit IsNan prüfen.

[Stevie]

Das Feature Nullables in Delphi sollte mehr umfassen, als das was oben skizziert und auch in unzähligen Bibliotheken seit vielen Jahren vorhanden ist.
Nämlich das, was man nicht mit so nem Record abbilden kann: operator hoisting (also ich kann die Operatoren darauf anwenden, die ich auch auf den typen in T anwenden kann), nullable propagation (ggf auch sowas wie den "Elvis" Operator aus C#).
Besser, sie nehmen sich dafür Zeit, wo sie ja so "viele" Compiler-Entwickler haben, gell? ;)