Spring4D: Nullables

[HeZa]

Zitat von Sir Rufo:

Weil du dann aus einer Datenbank die Werte direkt zuweisen kannst und ein NULL -Wert dann korrekt zugewiesen wird.

Den Wunsch nach einer einfachen Zuweisung für ein Datenbank-Feld kann ich nachvollziehen. Dafür aber die Typ-Sicherheit beim Kompilieren aufzugeben wäre mir ein zu hoher Preis.

Mein Vorschlag

• Implizite Variant Zuweisung aus Spring.Nullable<T> entfernen
• Helper-Klasse für TDataSet mit AsNullable<T>

Dann könnte man schreiben

Delphi-Quellcode:

var
  myNullableInt: Spring.Nullable<T>
...
  myNullableInt := myQuery.FieldByName('MY_FELD').AsNullable<Integer>;
  // alternative Syntax
  myNullableInt := myQuery.NullableField<Integer>('MY_FELD');

[Der schöne Günther]

Ich verstehe eins hierbei noch nicht:

Warum ist denn die Variant-Geschichte eigentlich Implicit und nicht Explicit?

Wäre Sie es, kann ich immer noch sagen
myNullableInt := myDatabaseField.Value oder
myNullableInt := myStrangeVariant

Ich kann allerdings nicht mehr sagen
myNullableInt := myFloatValue

[Dejan Vu]

Wenn also Nullables beliebigen Typs sein können, wieso verwende ich nicht dann einfach Variants?

[Sir Rufo]

Zitat von Dejan Vu:

Wenn also Nullables beliebigen Typs sein können, wieso verwende ich nicht dann einfach Variants?

Ein Nullable<T> soll eben nicht alles beinhalten, sondern typsicher einen Wert vom Typ T oder eben nichts.

[Dejan Vu]

Zitat von Sir Rufo:

Ein Nullable<T> soll eben nicht alles beinhalten, sondern typsicher einen Wert vom Typ T oder eben nichts.

Ach so. Und es geht darum, das man einem typsicheren Nullable<Integer> auch einen String zuweisen kann, ohne das es knallt (also eher 'ein bisschen typsicher'). Und das der Wert dann 0 ist.

Na ja. Ein etwas besseres 'VarToInt' (aka convert) tut's ja auch. Also: Ich weise einem Variant zu, was ich will und erst beim Auslesen interpretiere ich, was da drin steht. Hmm. Vom Verhalten sehe ich jetzt nicht so den Unterschied zu normalen Variants, aber egal.

[Sir Rufo]

Zitat von Dejan Vu:

Zitat von Sir Rufo:

Ein Nullable<T> soll eben nicht alles beinhalten, sondern typsicher einen Wert vom Typ T oder eben nichts.

Ach so. Und es geht darum, das man einem typsicheren Nullable<Integer> auch einen String zuweisen kann, ohne das es knallt (also eher 'ein bisschen typsicher'). Und das der Wert dann 0 ist.

Na ja. Ein etwas besseres 'VarToInt' (aka convert) tut's ja auch. Also: Ich weise einem Variant zu, was ich will und erst beim Auslesen interpretiere ich, was da drin steht. Hmm. Vom Verhalten sehe ich jetzt nicht so den Unterschied zu normalen Variants, aber egal.

Nach meinem Verständnis (und auch meiner Implementierung) kann einem Nullable<Integer> eben kein string zugewiesen werden. Mein Nullable<T> hat auch keinen impliziten Cast von einem Variant , denn nach meinem Verständnis soll ein Nullable<T> eben nicht alles beinhalten, sondern typsicher den angegebenen Typen T oder eben nichts.

Genau das steht auch schon in meinen Beiträgen hier ...

Und wie immer ist dieses Konstrukt einfach nur zum Vereinfachen gedacht:

Delphi-Quellcode:

var
  a,b,c : Nullable<Integer>;
  d : Integer;
begin
  a := Nullable.Null;
  b := 42;
  c := a+b; // c => Null
  d := a.ValueOrDefault() + b.ValueOrDefault(); // d => 42
end;

[Stevie]

Dann mach doch deinen Nullable open Source, Günther kann ihn nutzen und wir ersparen uns die ewige Im-Kreis-Dreherei.

P.S. Was macht eigtl dein Add overload bei Typen, bei denen es keine Addition gibt?

[Dejan Vu]

Zitat von Sir Rufo:

meinem ... meiner ... Mein ... meinem ... meinen

Laut Titel geht es um Spring4D: Nullables.

Seitdem ich Nullables in C# entdeckt habe, trauere ich den Variants hinterher. Auf der anderen Seite brauche ich sie eigentlich nie.

[Stevie]

Zitat von Der schöne Günther:

Ich verstehe eins hierbei noch nicht:

Warum ist denn die Variant-Geschichte eigentlich Implicit und nicht Explicit?

Wäre Sie es, kann ich immer noch sagen
myNullableInt := myDatabaseField.Value oder
myNullableInt := myStrangeVariant

Ich kann allerdings nicht mehr sagen
myNullableInt := myFloatValue

Nö, implicit heißt normale Zuweisung, explicit heißt, dass man einen Hardcast nutzen muss.

Also so:
myNullableInt := Nullable<Integer>(myDatabaseField.Value); oder
myNullableInt := Nullable<Integer>(myStrangeVariant)

[Der schöne Günther]

Zitat von Stevie:

Nö, implicit heißt normale Zuweisung, explicit heißt, dass man einen Hardcast nutzen muss.

Hardcast, oder gleich den passenden Typen reinstecken. Also myDatabaseField.Value . Das will man im Endeffekt doch.

Oder ist es tatsächlich, wie Dejan Vu meint, nur als eine andere Schreibweise für Variants gedacht?

Delphi-Quellcode:

      class operator Explicit(const from: Variant): Nullable<T>;
      class operator Implicit(const from: T): Nullable<T>;

erlaubt:

Delphi-Quellcode:

var
   myWrapper: TWrapper<Integer>;
   myVariant: Variant;
begin
   myWrapper := 42;

   //myWrapper := 'Hallo'; // nope

   myWrapper := Variant('Hallo');
   // oder
   myVariant := 'Hallo';
   myWrapper := myVariant;
end.