[[AgustinOrtu]]

De primeras, no se puede, porque los tipos primitivos no son "nullables". Alguna de las formas de solucionarlo es usar "valores bandera", es decir, definir un valor en tus reglas de negocio que se asuma como "invalido".

Por ej:

Código Delphi [-]
  NullValues = record
  public
    const EmptyDateTime = 0; // por poner cualquier cosa
    const EmptyInteger = -1234; // por poner cualquier cosa

    class function IsEmptyDateTime(const Value: TDateTime): Boolean; static; inline;
    class function IsEmptyInteger(const Value: Integer): Boolean; static; inline;
  end;

La implementacion de los metodos es trivial (comparas el valor que recibes contra la constante)

Una solucion mejor es el uso de una biblioteca que soporte los llamados tipos "nullables"

Spring4D ofrece una solucion muy buena, es OpenSource y es compatible con Delphi 2010 o superior. Los nullable se definen en la unidad Spring.pas

Código Delphi [-]
uses
  System.SysUtils,
  System.Variants,
  Spring;

procedure Main;
var
  Int: TNullableInteger;
begin
  Int := TNullableInteger.Create(5); // creacion
  Int := 5;                          // equivalente al anterior, la sobrecarga del operador implicito hace la magia
  Writeln(Int.HasValue);             // --> True

  Int := TNullableInteger.Create(System.Variants.Null); // lo setea a null
  Writeln(Int.HasValue);                                // --> False

  try
    Writeln(Int.Value); // --> exception
  except
    on E: EInvalidOperationException do
    begin
      Writeln('Nullable no tenia valor asignado');
    end
    else
      raise;
  end;
end;

El uso con cualquier tipo (gracias a los genericos y a TNullable<T> es posible) y la sobrecarga de operadores (sobre todo el implicito) lo hace muy limpio

En realidad, TNullable<T> es un record que se aprovecha de como estan implementados en Delphi para setear un Flag de "HasValue = True/False" dependiendo de como fue instanciada la variable

Por ej:

Código Delphi [-]
procedure UsarInt(const Value: Integer);
begin
  WriteLn(Value.ToString);
end;

procedure Main;
var
  Int: TNullableInteger;
begin
  UsarInt(Int); // excepcion porque esto implica llamar al operador implicito y ejecutar un Int.Value
  Int := 5;
  UsarInt(Int); // ahora todo bien
end;

La unica "pega" es que no podes usar (directamente) los ayudantes como TStringHelper sobre una variable de tipo Nullable: por mas que tengas el operador implicito, te obliga a escribir ".Value"

Código Delphi [-]
var
  Int: TNullableInteger;
begin
  Int.ToString; // no compila
  Int.Value.ToString; // todo bien
end;

Si no recuerdo mal en los proximos releases de Delphi estos "nullables" van a estar implementados de manera nativa y no hara falta usar bibliotecas externas