NullableTypes

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (2)  (1)

Tratando valores nulos no Delphi 2005.

- Tratando valores nulos no Delphi 2005

 

Nulo. [Do lat. nullu]Adj. 1. Que não é válido; que não tem valor 2. Sem valor ou sem efeito; inútil, vão 3. Nenhum 4. Inepto, incapaz 5. Inerte

 

Quando vamos desenvolver softwares que utilizam banco de dados normalmente encontramos um problema: a representação do valor NULL. Existem diversas técnicas para solucionar o problema.

As mais simples utilizam valores pré-definidos para representar o valor nulo, por exemplo, uma string vazia para um campo alfanumérico, e 0 ou -1 para campos numéricos e datas. Essas estratégias são fáceis de implementar, porém apresentam outro problema se você precisa utilizar toda a faixa de valores (ex: de 0 a 255 para um campo Byte) ou precisa diferenciar se um campo alfanumérico não está preenchido ou se ele foi preenchido com uma string vazia.

Já as mais elaboradas fazem uso de objetos ou estruturas que além de guardar o valor do campo, guardam também se ele é nulo ou não. Até o Delphi 7, quem precisasse desse mecanismo entrava num dilema ao ter que escolher entre utilizar classes (para encapsular certos comportamentos com o custo de utilizar o heap) ou records (simplesmente para guardar dados utilizando o stack). Apesar de no .Net termos recursos adequados para uma implementação eficaz de tipos nulos, felizmente não precisamos fazê-lo, pois podemos utilizar o projeto de código aberto (licença MIT) NullableTypes.

Conhecendo NullableTypes

Programado em C#, por um italiano conhecido por “luKa”, o NullableTypes é  um conjunto de tipos que funcionam como os tipos internos do .Net. Por serem estruturas, eles são “leves” (ficando no stack), não precisam ser instanciados e são sempre passados por valor. Essas características são as mesmas de todos os outros Value-Types do .Net (Int32, String, Boolean e etc). Além disso, essas estruturas possuem métodos que encapsulam comportamentos básicos como conversões, comparações, operações matemáticas e serialização.

Cada NullableType foi feito para representar um tipo nativo do .Net e todos implementam a interface INullable, representando o fato que todos eles podem conter um valor nulo.

Os tipos implementados pelo NullableTypes são: NullableBoolean, NullableByte, NullableDateTime, NullableDecimal, NullableDouble, NullableInt16, NullableInt32, NullableInt64, NullableSingle, NullableString.

A interface INullable contém apenas uma propriedade somente-leitura “IsNull” que indica se o valor é nulo ou não. Importante notar que ser “nulo” significa que o valor está faltando, é desconhecido ou é inaplicável. Além disso, é bom deixar claro algumas regrinhas que se aplicam aos valores nulos:

1. Um valor nulo não pode implicar em nenhum outro valor e vice-e-versa. Nulo é simplesmente nulo;

2. Qualquer comparação ou operação aritmética envolvendo pelo menos um operando nulo retornará nulo.

Instalando NullableTypes

Para instalar NullableTypes clique com o botão direito no Project Manager e escolha a opção Add Reference. Em seguida, selecione o assembly “NullableTypes.dll”. Confirme a operação clicando em Ok (Figura 1).

 

Figura 1. Instalando NullableTypes

Exemplos Práticos

Listagem 1. Exemplo de uso.

procedure TForm1.btnNullableTypes1Click(Sender: TObject);

{$REGION 'Declaracoes'}

var

  nint: NullableInt32;

  nullint: NullableInt32;

  nbool: NullableBoolean;

  i: integer;

{$ENDREGION}

begin

  {$REGION 'Inicializacoes'}

  //Aqui antes da atribuição ocorre uma conversão implícita de um Int32

  //para um NullableInt32

  nint := 320;

  nullint := NullableInt32.Null;

  i := 10;

  {$ENDREGION}

 

  {$REGION 'Testes de conversao'}

  //Uma conversão implícita acontece antes da atribuicao mas só

  //depois da soma entre a variável "i" e o 100

  nint := i + 100; //nint = 330

 

  //Antes da atribuição ocorre uma conversão implícita da variável "i"

  //que é Int32 em um NullableInt32

  nint := i; //nint = 10

 

  //A conversão de um NullableInt32 para um Int32 deve ser explícita

  //e levantará uma exceção caso a variável "nint" seja nula

  i := Int32(nint); //i = 10

  {$ENDREGION}

 

  {$REGION 'Testes de comparacao'}

  //Para fazer uma expressão como "nint > 10" deve-se utilizar

  //a funcão GreaterThan, e o 10 será implicitamente convertido para

  //um NullableInt32

  //Note que o fato dessa função retornar falso não implica que "nint <= 10"

  //pois pode ser que nint seja nulo

  if (NullableInt32.GreaterThan(nint,10).IsTrue) then

    MessageBox.Show('nint > 10')

  else

    MessageBox.Show('nint <= 10 ou é nulo');

 

  //Outro modo de codificar

  if (nint.IsNull and (nint.Value > 10)) then

    MessageBox.Show('nint > 10')

  else

    MessageBox.Show('nint <= 10 ou é nulo');

 

  //Mais um modo de codificar mas agora usando a variável "nullint"

  if (nullint.IsNull) then

    MessageBox.Show('nullint é nulo')

  else if (nullint.Value > 10) then

    MessageBox.Show('nullint > 10')

  else

    MessageBox.Show('nullint <= 10');

  {$ENDREGION}

end;

 

Para facilitar a conversão dos NullableTypes em outros tipos do .Net existem duas classes estáticas: a DBNullConvert e a NullConvert.

A classe NullConvert contém métodos para converter NullableTypes em tipos não nulos do .Net e vice-e-versa. Ela é muito útil na camada de apresentação, visto que nenhum controle do .Net suporta tipos nulos. Utilize o método From passando um NullableType e o valor que você deseja que seja retornado caso o valor seja nula; ele retornará o valor num tipo nativo do .Net. Use os métodos To<nullabletype>, onde “<nullabletype>” é o tipo para que você quer converter, passando um tipo nativo do .Net e o valor que você deseja que seja considerado como nulo; e eles retornarão um NullableType (Listagem 2).

 

Listagem 2. Exemplo de NullConvert.

procedure TesteNullConvert;

var

  dataDotNet: DateTime;

  dataNullable: NullableDateTime;

begin

  //inicializa dataNullable com um valor nulo

  dataNullable := NullableDateTime.Null;

  //dataNullable é nula

  //converte para um tipo nativo usando a data 01/01/1000 se for nulo

  dataDotNet := NullConvert.From(dataNullable,DateTime.Create(1000,1,1));

  //dataDotNet = 01/01/1000

  //converte de volta para um NullableType considerando a data 01/01/2000 como nula

 dataNullable:= NullConvert.ToNullableDateTime(dataDotNet,DateTime.Create(2000,1,1));

  //dataNullable = 01/01/1000

  //pois esse valor não foi considerado como nulo e sim como um valor válido

end;

 

Já a classe DBNullConvert contém métodos para converter entre NullableTypes e os valores vindos dos Data Providers (usados como parâmetros da classe Command e valores retornados pelo DataReader) e dos Datasets (valores da propriedades Items de um DataRow). O método From recebe um parâmetro NullableType e retorna um SqlType. Os métodos To<nullabletype>, onde “<nullabletype>” é o tipo para que você quer converter, recebem um Object (que deve ser um ValueType ou um SqlType) e eles retornarão um NullableType (Listagem 3).

 

Listagem 3. Exemplo de DBNullConvert.

procedure TesteDbNullConvert;

var

  dataNullable: NullableDateTime;

  dt: System.Data.DataTable;

  row: System.Data.DataRow;

begin

  //inicializa dataNullable com um valor nulo

  dataNullable := NullableDateTime.Create(2005,08,12);

  //dataNullable é 12/08/2005

  //cria e inicializa um DataTable

  dt := DataTable.Create;

  dt.Columns.Add('data', &Type.GetType('System.DateTime'));

  dt.Columns['data'].AllowDBNull := true;

  //cria uma nova linha para o DataTable

  row := dt.NewRow;

  row['data'] := DBNullConvert.From(dataNullable);

  //a coluna 'data' do DataRow agora vale 12/08/2005

  row['data'] := DBNull.Value;

  //a coluna 'data' do DataRow agora vale NULL

end;

NullableTypes x SQLTypes

No framework .Net também encontramos os SqlTypes, que são tipos que implementam uma interface INullable e tem praticamente os mesmo comportamento do NullableTypes. No entanto, os SqlTypes são fortemente ligados com os tipos nativos dos banco de dados e devem ser utilizados apenas na camada de acesso a dados. Para a camada de negócio e apresentação é fortemente recomendado que você utilize outros tipos que sejam independentes de banco, que é o caso dos NullableTypes. Além de não depender de nenhum banco de dados, os NullableTypes são melhores que os SqlTypes porque suportam serialização (logo funcionam com remoting e webservices) e têm classes auxiliares que ajudam na integração com controles para Web/WinForms e na conversão de e para valores de banco de dados.

Dicas Importantes

Como acontece com toda boa novidade, o uso de NullableTypes requer atenção por causa de algumas características do framework. Vamos a algumas delas:

A herança do C#

Todo programador C sabe: a divisão entre inteiros só pode retornar um inteiro. Ou seja, justamente o que não acontece quando realizamos a mesma operação no Delphi. Porém, é a antiga regra do C que prevalece (sim, em pleno Delphi !!) com operações envolvendo NullableInt32. Este comportamento acontece porque NullableTypes foi desenvolvido em C# e grande parte do código do projeto está concentrado na sobrecarga de operadores. O exemplo da Listagem 4 deixa isto bem claro.

 

Listagem 4. Diferenças na divisão com NullableTypes.

procedure TWinForm.Button1_Click(sender: System.Object; e: System.EventArgs);

var

  UmNullableInteger, OutroNullableInteger, MaisUmNullableInteger: NullableInt32;

  UmDelphiInteger, OutroDelphiInteger: Integer;

  UmDelphiDouble: Double;

  UmNullableDouble: NullableDouble;

begin

  UmDelphiInteger    := 1;

  OutroDelphiInteger := 2;

 

  // Todo programador Delphi sabe que o resultado de uma divisão entre inteiros

  // não pode ser associado a um inteiro...

  UmDelphiDouble := UmDelphiInteger / OutroDelphiInteger;

  UmNullableInteger := 1;

  OutroNullableInteger := 2;

 

  // ... mas isso não se aplica quando utilizamos NullableTypes. A divisão entre

  // inteiros sempre retorna um inteiro !

  UmNullableDouble    := UmNullableInteger / OutroNullableInteger;

  MaisUmNullableInteger := UmNullableInteger / OutroNullableInteger;

 

  MessageBox.Show(UmDelphiDouble.ToString);  // Saída: 0,5

  MessageBox.Show(MaisUmNullableInteger.ToString); // Saída: 0

  MessageBox.Show(UmNullableDouble.ToString); // Saída: 0

end;

NullableBoolean: um paradoxo ?

Como já foi demonstrado anteriormente, sempre que se tentar acessar a propriedade Value, devemos fazer uma checagem utilizando o método IsNull. Porém, seria muito trabalhoso fazer estas checagens com NullableBoolean. Seria complexo, por exemplo, testar se três condições são verdadeiras (Listagem 5).

 

Listagem 5. Uma maneira complicada de utilizar NullableBoolean.

procedure TWinForm.Button3_Click(sender: System.Object; e: System.EventArgs);

var

  condicao1, condicao2, condicao3: NullableBoolean;

begin

  if ((not condicao1.isNull) and condicao1.Value) and

     ((not condicao2.isNull) and condicao2.Value) and

     ((not condicao3.isNull) and condicao3.Value) then

    MessageBox.Show('verdadeiro')

  else

    MessageBox.Show('falso');

end;

 

É para esse tipo de situação que servem os métodos IsTrue e IsFalse. Assim podemos simplificar o código, como demonstrado na Listagem 6.

 

Listagem 6. Simplificando o uso de NullableBoolean.

procedure TWinForm.Button3_Click(sender: System.Object; e: System.EventArgs);

var

  condicao1, condicao2, condicao3: NullableBoolean;

begin

  condicao1 := True;

  condicao2 := True;

  condicao3 := False;

 

  if condicao1.IsTrue and condicao2.IsTrue and condicao3.IsTrue then

    MessageBox.Show('verdadeiro')

  else

    MessageBox.Show('falso');

end;

 

É importante lembrar que um NullableBoolean nulo não é nem verdadeiro e nem falso. Ou seja, um nulo enquanto Boolean simplesmente não pode ser avaliado e não será verdadeiro, nem falso. Será simplesmente nulo. Parece um ‘paradoxo’ quando pensamos em NullableBoolean como tendo dois estados possíveis, tal qual é o Boolean. Mas a verdade é que NullableBoolean tem três estados: True, False e Null.

 

Listagem 7. Diferenças entre NullableBoolean e Boolean.

procedure TWinForm.Button4_Click(sender: System.Object; e: System.EventArgs);

var

  condicaonula: NullableBoolean;

begin

  condicaonula := NullableBoolean.Null;

  if condicaonula.IsTrue then

    MessageBox.Show('Condição nula é verdadeira !');

  if condicaonula.IsFalse then

    MessageBox.Show('Condição nula é falsa !');

  // Para um Boolean, não ser verdadeiro é ser falso

  if (not True) = False then

    MessageBox.Show('Para um Boolean, não ser verdadeiro é ser falso !');

  // Porém, para um NullableBoolean, isso nem sempre é verdade. Paradoxo ?

  if (not condicaonula.IsTrue) = condicaonula.IsFalse then

    MessageBox.Show('Esta mensagem nunca será exibida.')

  else

  begin

    MessageBox.Show('not IsTrue é diferente de IsFalse ?! Um paradoxo ??');

    // Na verdade não existe paradoxo, NullableBoolean é que tem 3 estados.

    if condicaonula.IsNull then

    begin

      MessageBox.Show('Ok, nada de paradoxos. Esta é uma condição nula...' );

      MessageBox.Show('... e NullableBoolean tem 3 estados. :) ');

    end;

  end;

end;

 

Links

http://nullabletypes.sourceforge.net/

Site Oficial do NullableTypes

 

Marcelo Pereira Rocha (mrocha@borland.com) é Borland Delphi 7 Certified Developer, Técnico em Informática Gerencial formado pelo Colégio Cotemig  e Tecnólogo em Processamento de Dados formado pelo Centro Universitário da União de Negócios e Administração de Minas Gerais (UNA-MG). Atualmente desenvolve sistemas web em .Net voltados para a área governamental. Atua como consultor para a Borland Latin America (Professional Services Organization).

 

Vitor Ciaramella (vitorc@gmail.com) é Analista e Arquiteto .Net.  Possui ampla experiência com definição de requisitos, análise, arquitetura e desenvolvimento de sistemas em .Net (Delphi e C#). É instrutor Certificado em Borland Delphi 7, RAVE, ModelMaker e Intraweb e está cursando Análise de Sistemas pela PUC-Campinas. Atualmente trabalha como consultor para a Borland Latin America (Professional Services Organization).

 

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?