Definičné a vývojové prostredie - skriptovanie

Nepoužívejte Globální proměnné, nelze zajistit jejich správnou inicializaci, protože sekce mezi begin end na konci unit se nevolá.

Příklad chybné konstrukce:

var
	GlobalFlag: Boolean;
begin
	GlobalFlag := True; //Toto se nikdy nezavolá
end.	

Doporučujeme použít globální úložiště GlobParams, jehož použití můžete navíc zabalit do snadno použitelných funkcí:

//Funkce pro získání hodnoty
function GlobalFlag: Boolean;
begin
  Result := GlobParams.ParamAsBoolean('GlobalFlag', True);
end;

//Procedura pro nastavení hodnoty
procedure SetGlobalFlag(AValue: Boolean);
var
  mPar: TNxParameter;
begin
  mPar:= GlobParams.GetOrCreateParam(dtBoolean, 'GlobalFlag');
  mPar.AsBoolean := AValue;
end;	

Příklad chybné konstrukce:

procedure DoSomething(AOS: TNxCustomObjectSpace; AValue: Integer);
var
  mBO: TNxCustomBusinessObject;
begin
  try
    case aValue of
      1: mBO:= AOS.CreateObject(Class_Firm);
      2: mBO:= AOS.CreateObject(Class_Person);
    end;
  finally
    mBO.Free; //Není nezaručeno, že mBO bude správně inicializovaný
  end;
end;	

Správná konstrukce je tedy následující:

procedure DoSomething(AOS: TNxCustomObjectSpace; AValue: Integer);
var
  mBO: TNxCustomBusinessObject;
begin
  try
    case aValue of
      1: mBO:= AOS.CreateObject(Class_Firm);
      2: mBO:= AOS.CreateObject(Class_Person);
    else
      mBO := nil;  
    end;
  finally
    mBO.Free; //Je zaručeno, že mBO bude správně inicializovaný a volat .Free nad objektem, který je nil není problém
  end;
end;	

Případně lze použít tuto konstrukci:

procedure DoSomething(AOS: TNxCustomObjectSpace; AValue: Integer);
var
  mBO: TNxCustomBusinessObject;
begin
  mBO := nil;
  try
    case aValue of
      1: mBO:= AOS.CreateObject(Class_Firm);
      2: mBO:= AOS.CreateObject(Class_Person);
    end;
  finally
    mBO.Free; //Je zaručeno, že mBO bude správně inicializovaný a volat .Free nad objektem, který je nil není problém
  end;
end;	

Je třeba destruovat všechny neinterfacové objekty.

Mezi typické neinterfacové objekty patří například TStringList, TNxParameteters.

Neuvolněním vytvořených objektů vznikají memory leaky, které při častém opakování mohou po delší době znamenat pád programu způsobený vyčerpáním zdrojů (USER objektů, GDI objektů nebo operační paměti).

Příklad chybné konstrukce:

procedure DoSomething;
var
  mSL: TStringlist;
begin
  mSL:= TStringlist.Create;
  mSL.Add('Takto vznikne memory leak');
end;	

Správná konstrukce je tedy následující:

procedure DoSomething;
var
  mSL: TStringlist;
begin
  mSL:= TStringlist.Create;
  try
    mSL.Add('Takto nevznikne memory leak');
  finally
    mSL.Free;
  end;   
end;	

V případě potřeby současně inicializovat více objektů najednou lze použít i konstrukci uvedenou níže.

Tou lze obejít mnohonásobné zanoření try a finally do sebe, což pak značně znepřehledňuje kód.

Předpokladem je, že:

• Všechny objekty musí být před try nainicializované na nil.

• Destruktory všech uvolňovaných objektů jsou napsány tak, aby v jejich průběhu nedošlo k vzniku výjimky.

procedure DoSomething;
var
  mSL1, mSL2: TStringlist;
begin
  mSL1:= nil;
  mSL2:= nil; 
  try
    mSL1:= TStringlist.Create;
    mSL1.Add('Takto nevznikne memory leak');
    
    mSL2:= TStringlist.Create;
    mSL2.Add('Takto nevznikne memory leak');
  finally
    mSL1.Free;
    mSL2.Free;
  end;   
end;	

Některé metody umožní získat odkaz nově vytvořený nebo již existující interface objekt. Zároveň si však při tomto požadavku vytvoří tzv. Holder, který si drží referenci na originální interface objekt.

Jedná se o relativně komplikovanou konstrukci, kterou je zbytečné zde celou popisovat. Podstatné je, že nad získaným odkazem na instancí objektu musíme zavolat metodu Free, která automaticky zajistí destrukci Holderu, a tím nastane i uvolnění reference na originální interface objekt.

Tím se originální objekt nemusí okamžitě uvolnit, pokud na něj existuje jinde v programu nějaká další reference, ale uvolní se automaticky v okamžiku, kdy počet referencí na něj klesne na nulu.

Pokud bychom nad získaným odkazem metodu Free nezavolali, držel by si neuvolněný Holder stále referenci na originální interface objekt a ten by se nikdy neuvolnil. Tím by vznikl memory leak. Je třeba brát v úvahu, že mezi nejběžnější interface objekty patří v ABRA Gen Business objekty, jejichž struktura bývá často členitá, a vzniklý memory leak tam může být relativně velký.

Existuje i řada funkcí a property objektů, které vrací odkaz na již existující interface objekt, a tak z jejich názvu není patrné, že je nutné pro ně volat metodu Free.

Seznam všech funkcí a property objektů pro které je třeba volat následně Free, je uvedená výše.

I když property CurrentObject nevytvoří žádný Business objekt, u kterého by se uživatel mohl domnívat, že ho musí na konci uvolnit, je i přesto voláním této property vytvořen výše zmíněný Holder, který si drží referenci na Business objekt DynSite. Pokud nezavoláme mBO.Free, nedojde k uvolnění Holderu, který si tak bude stále držet referenci na Business objekt DynSite, který tímto rovněž také nikdy neuvolní. Tím vznikne memory leak, a to jak na Holder, tak i na Business objekt DynSite.

Příklad chybné konstrukce:

procedure DoSomething(ASite: TDynSiteForm);
var
  mBO: TNxCustomBusinessObject;
begin
  mBO := ASite.CurrentObject;
  mBO.SetFieldValueAsBoolean('MyField', True);
  mBO.Save;
end;	

Správná konstrukce je tedy následující:

procedure DoSomething(ASite: TDynSiteForm);
var
  mBO: TNxCustomBusinessObject;
begin
  mBO := ASite.CurrentObject;
  try
    mBO.SetFieldValueAsBoolean('MyField', True);
    mBO.Save;
  finally
    mBO.Free; 
  end;  
end;	

Volání mOS.Free nic neudělá. Jen přistoupí k danému objektu, a protože ten nemá Holder, tak nic neprovede (neuvolní ho).

Příklad chybné konstrukce:

procedure DoSomething(ASite: TDynSiteForm);
var
  mOS: TNxCustomObjectSpace;
begin
  mOS := ASite.BaseObjectSpace;
  try 
    ...
  finally  
    mOS.Free; //Nic neudělá 
  end;  
end;	

Správná konstrukce je tedy následující:

procedure DoSomething(ASite: TDynSiteForm);
var
  mOS: TNxCustomObjectSpace;
begin
  mOS := ASite.BaseObjectSpace;
  ...
end;	

Jedná se o situaci, kdy například metodou ObjectSpace.CreateObject vytvoříme nový hlavní Business objekt a následně si v některé z jeho kolekcí vytvoříme novou položku.

V takovém případě je třeba provést destrukci pouze na hlavní Business objekt a nikoliv na vytvořenou položku v kolekci, protože o destrukci položky se postará sám hlavní objekt, resp. jeho Moniker dané kolekce.

Příklad chybné konstrukce:

procedure DoSomething(ASite: TDynSiteForm);
var
  mObjectSpace: TNxCustomObjectSpace;
  mBO: TNxCustomBusinessObject;
  mRows: TNxCustomBusinessMonikerCollection;
  mRow: TNxCustomBusinessObject;
begin
  mObjectSpace := ASite.BaseObjectSpace;
  mBO:= mObjectSpace.CreateObject(Class_PLMPieceList);
  try
    mBO.Load('1000000101');
    mRows := mBO.GetLoadedCollectionMonikerForFieldCode(mBO.GetFieldCode('ROWS'));
    mRow := mRows.AddNewObject;
  finally  
    mBO.Free;
    mRow.free; //Zde to spadne na výjimku, protože se pokusíte přistoupit k již zdestruovanému objektu
  end;
end;	

Správná konstrukce je tedy následující:

procedure DoSomething(ASite: TDynSiteForm);
var
  mObjectSpace: TNxCustomObjectSpace;
  mBO: TNxCustomBusinessObject;
  mRows: TNxCustomBusinessMonikerCollection;
  mRow: TNxCustomBusinessObject;
begin
  mObjectSpace := ASite.BaseObjectSpace;
  mBO:= mObjectSpace.CreateObject(Class_PLMPieceList);
  try
    mBO.Load('1000000101');
    mRows := mBO.GetLoadedCollectionMonikerForFieldCode(mBO.GetFieldCode('ROWS'));
    mRow := mRows.AddNewObject;
  finally  
    mBO.Free;
  end;
end;	

Přípustná je i následující konstrukce, ovšem volání mRow.Free nic neudělá. Jen přistoupí k danému objektu, a protože ten nemá Holder, tak nic neprovede (neuvolní ho).

procedure DoSomething(ASite: TDynSiteForm);
var
  mObjectSpace: TNxCustomObjectSpace;
  mBO: TNxCustomBusinessObject;
  mRows: TNxCustomBusinessMonikerCollection;
  mRow: TNxCustomBusinessObject;
begin
  mObjectSpace := ASite.BaseObjectSpace;
  mBO:= mObjectSpace.CreateObject(Class_PLMPieceList);
  try
    mBO.Load('1000000101');
    mRows := mBO.GetLoadedCollectionMonikerForFieldCode(mBO.GetFieldCode('ROWS'));
    mRow := mRows.AddNewObject;
  finally  
    mRow.Free; //Nic neudělá
    mBO.Free;
  end;
end;	

Vždy je třeba dbát na to, aby vytvoření objektu bylo před try a destrukce objektu je ve finally, a to samozřejmě na stejné úrovni.

Zároveň upozorňujeme na častou chybu, kdy je objekt vytvářen v cyklu, ale destruován je pouze jednou, nebo je naopak vytvořen pouze jednou a destruován je v cyklu.

Příklad chybné konstrukce: Business objekt se vytváří n-krát v cyklu, ale uvolní se pouze ten poslední. Z tohoto důvodu může dojít ke vzniku memory leaků. Navíc pokud by parametr aSL neobsahoval žádnou položku, mohlo by dojít k uvolnění neinicializované proměnné mBO.

procedure DoSomething(ASite: TDynSiteForm);
var
  mOS: TNxCustomObjectSpace;
begin
  mOS := ASite.BaseObjectSpace;
  try 
    ...
  finally  
    mOS.Free; //Nic neudělá 
  end;  
end;	

Další příklad chybné konstrukce: Business objekt se vytváří pouze jednou, ale destruuje se v cyklu.

Toto velmi pravděpodobně způsobí vznik výjimky při opakovaném volání metody Load, protože ta se bude aplikovat na již zdestruovaném objektu.

procedure DoSomething(ASite: TDynSiteForm; aSL: TStringList);
var
  mObjectSpace: TNxCustomObjectSpace;
  mBO: TNxCustomBusinessObject;
  I: Integer;
begin
  mObjectSpace := ASite.BaseObjectSpace;
  mBO:= mObjectSpace.CreateObject(Class_PLMPieceList); //Business objket se vytváří pouze jednou
  for I:=0 to aSL.Count-1 do
  begin 
    try
      mBO.Load(SL[I]); //Zde se při opakovaném průchodu zavolá Load nad již zdestruovaným Business objektem
      ...
    finally  
      mBO.Free; //Ale destruuje se v cyklu
    end;
  end;  
end;	

Správná konstrukce je tedy následující:

procedure DoSomething(ASite: TDynSiteForm; aSL: TStringList);
var
  mObjectSpace: TNxCustomObjectSpace;
  mBO: TNxCustomBusinessObject;
  I: Integer;
begin
  mObjectSpace := ASite.BaseObjectSpace;
  for I:=0 to aSL.Count-1 do
  begin 
    mBO:= mObjectSpace.CreateObject(Class_PLMPieceList); //Business objket se vytváří v cyklu
    try
      mBO.Load(SL[I]); //Load se zavolá vždy nad novou instancí Business objektu
      ...
    finally  
      mBO.Free; //Business objekt se rovněž destruuje v cyklu
    end;
  end;  
end;	

Přípustná je i konstrukce níže, avšak pouze za předpokladu, že se v cyklu po Load nevolá Save. ABRA Gen neumožňuje jeden a ten samý objekt používat ve výchozím stavu opakovaně a nahlásí chybu.

procedure DoSomething(ASite: TDynSiteForm; aSL: TStringList);
var
  mObjectSpace: TNxCustomObjectSpace;
  mBO: TNxCustomBusinessObject;
  I: Integer;
begin
  mObjectSpace := ASite.BaseObjectSpace;
  mBO:= mObjectSpace.CreateObject(Class_PLMPieceList); //Business objket se vytváří pouze jednou
  try  
    for I:=0 to aSL.Count-1 do
    begin 
      mBO.Load(SL[I]); //Load se zavolá stále na nd stejnou instancí Business objektu
      ...
    end;  
  finally  
    mBO.Free; //Business objekt se rovněž destruuje pouze jednou
  end;
end;	

Pokud nějaká námi vytvořená funkce vrací novou instanci objektu, pak ji musíme správně pojmenovat, aby bylo zřejmé, že vrácený objekt je třeba zdestruovat.

Například pokud naše funkce bude vytvářet novou instanci formuláře, pojmenujme ji CreateForm a výsledek vracejme v Resultu a ne var parametru.

Příklad chybné konstrukce: Z názvu funkce není na první pohled zřejmé, že vrací novou instanci formuláře, kterou je třeba následně zdestruovat.

function GetMyForm: TForm;
begin
  Result := TForm.Create(nil);
  ...
end;	

Příklad chybné konstrukce: Název procedury je již lepší, ale v Delphi není obvykle zvykem, aby procedura vracela novou instanci objektu ve var parametru.

procedure CreateMyForm(var AForm: TForm);
begin
  AForm := TForm.Create(nil);
  ...
end;	

Správná konstrukce:

function CreateMyForm: TForm;
begin
  Result := TForm.Create(nil);
  ...
end;