Sou um programador Delphi Pascal, uso o mais recente Embarcadero delphi XE e gostaria de tirar proveito de padrões de design, como Model view controller e model view view-model.
No entanto, não parece haver muito na web sobre as melhores práticas para fazer isso em pascal. A maioria dos exemplos que posso encontrar está em C # e alguns dos recursos de idioma não estão presentes no pascal, o que significa que talvez seja necessário encontrar maneiras de implementar esses recursos.
Estou tentando adaptar o código deste artigo aqui
Vou listar os problemas que estou enfrentando
- Tipos anuláveis
Pascal não tem tipos anuláveis como o C #, então eu criei os meus.
TNullable<T> = record
strict private
fHasValue : boolean;
fValue : T;
function GetValue:T;
procedure SetValue(newValue : T);
public
property HasValue : boolean read fHasValue;
property Value : T read GetValue write SetValue;
procedure SetToNull;
end;
na seção de implementação
function TNullable<T>.GetValue:T;
begin
if fHasValue then
begin
Result := fValue;
end
else raise Exception.Create('Value Not Set');
end;
procedure TNullable<T>.SetValue(newValue : T);
begin
fValue := newValue;
fHasValue := true;
end;
procedure TNullable<T>.SetToNull;
begin
fHasValue := false;
end;
- Obter / definir propriedades
Agora que tenho um tipo anulável, posso criar propriedades anuláveis. No entanto, ele vem com alguns odores de código
por exemplo, se eu criar
TFoo = class
private
function GetBar:TNullable<Integer>;
procedure SetBar(x:TNullable<Integer>);
public
property Bar : TNullable<Integer> read GetBar write SetBar;
na seção de implementação
function TFoo.GetBar:TNullable<Integer>;
begin
if **valueExists** then
begin
Result.Value := **the value**
end else
begin
Result.SetToNull;
end;
end;
procedure TFoo.SetBar(x:TNullable<Integer>);
begin
if X.hasValue then
begin
//Store/show value here
end else
begin
//handle null assignment here
end;
end;
Isso é bom, mas quando se trata de usar essas propriedades, não posso simplesmente usar
myFoo.Bar.Value: = 1;
Eu tenho que usar
var
myBar : TNullable<Integer>;
begin
myBar.Value := 1;
myFoo.Bar := myBar;
end;
O que é um pouco mais confuso. Suponho que não haja nada que eu possa fazer sobre isso.
- Referências circulares
Eu gosto de separar as aulas em diferentes unidades.
ou seja:
mantendo a interface do usuário separada da lógica de controle e da camada lógica de modelo e dados.
Eu posso ter uma situação em que duas classes podem se referir uma à outra. Embora essa seja uma situação que, na maioria das vezes, eu gostaria de evitar, há ocasiões em que isso é necessário.
por exemplo
unit u_A;
interface
uses
u_B
;
type
TA = class
public
Foo : TB;
end;
implementation
end;
e outra unidade
unit u_B;
interface
uses
u_A
;
type
TB = class
public
Foo : TA;
end;
implementation
end;
Esse código está quebrado porque as duas classes se incluem e isso não pode ser feito em pascal. Este não é um problema no C #. As soluções em que consigo pensar: 1. incluem as duas classes na mesma unidade, embora isso seja um problema se eu não achar que isso se adapte ao design. 2. Crie outra interface pai para B e herda B disso, então isso é contornado. Embora isso seja confuso para uma tarefa tão simples.
- Classes estáticas
Não há classes estáticas no Delphi, elas são úteis para classes de controle.
- Melhores classes de contêineres para usar no Delphi
Atualmente, estou usando TList e TObjectList em Generics.Collections Eles foram introduzidos no Delphi XE. Espero que sejam os melhores para usar, pois o delphi 7 não parecia ter boas opções.
Ainda estou pensando nos manipuladores de eventos e em quaisquer problemas que possam surgir por lá. Talvez haja outras questões em que ainda não pensei.
Obrigado por qualquer conselho.