Begrijp en voorkom geheugenlekken in Delphi

DelphiDe ondersteuning voor objectgeoriënteerd programmeren is rijk en krachtig. Klassen en objecten maken modulaire programmeren van codes mogelijk. Samen met modulairere en complexere componenten komen geavanceerdere en complexere componenten bugs.

Tijdens het ontwikkelen toepassingen in Delphi is (bijna) altijd leuk, er zijn situaties waarin je het gevoel hebt dat de hele wereld tegen je is.

Telkens wanneer u een object in Delphi moet gebruiken (maken), moet u het verbruikte geheugen vrijmaken (eenmaal niet meer nodig). Zeker, de try / eindelijk geheugenbeschermende blokken kunnen u helpen geheugenlekken te voorkomen; het is nog steeds aan jou om je code te beschermen.

Een geheugen (of bron) lek treedt op wanneer het programma de mogelijkheid verliest om het geheugen dat het verbruikt vrij te maken. Herhaalde geheugenlekken zorgen ervoor dat het geheugengebruik van een proces grenzeloos groeit. Geheugenlekken zijn een ernstig probleem - als u een code heeft die geheugenlek veroorzaakt, in een actieve applicatie 24/7 zal de applicatie al het beschikbare geheugen opeten en uiteindelijk de machine niet meer laten reageren.

De eerste stap om geheugenlekken te voorkomen, is te begrijpen hoe ze zich voordoen. Hieronder volgt een bespreking van enkele veelvoorkomende valkuilen en praktische tips voor het schrijven van niet-lekkende Delphi-code.

In de meeste (eenvoudige) Delphi-toepassingen, waarbij u de componenten (knoppen, memo's, bewerkingen, enz.) Gebruikt die u op een formulier laat vallen (tijdens het ontwerpen), hoeft u zich niet al te veel zorgen te maken over geheugenbeheer. Zodra het onderdeel op een formulier is geplaatst, wordt het formulier het formulier eigenaar en maakt het geheugen vrij dat door het onderdeel wordt ingenomen zodra het formulier is gesloten (vernietigd). Form is als eigenaar verantwoordelijk voor de toewijzing van geheugen aan de componenten die het host. Kortom: componenten op een formulier worden automatisch aangemaakt en vernietigd

In elke niet-triviale Delphi-applicatie zul je dat willen instantiseer Delphi componenten tijdens runtime. Je zult ook een aantal van je eigen aangepaste klassen hebben. Laten we zeggen dat je een klasse TDeveloper hebt met een methode DoProgram. Wanneer u nu de klasse TDeveloper moet gebruiken, maakt u een instantie van de klasse door de aan te roepen Creëer methode (constructor). De methode Maken wijst geheugen toe voor een nieuw object en retourneert een verwijzing naar het object.

var
zarko: TDeveloper
beginnen
zarko: = TMyObject. Creëren;
zarko. DoProgram;
einde;

En hier is een eenvoudig geheugenlek!

Telkens wanneer u een object maakt, moet u beschikken over het geheugen dat het in beslag heeft genomen. Om het geheugen van een toegewezen object vrij te maken, moet u de Vrij methode. Om zeker te zijn, moet je ook het blok try / eindelijk gebruiken:

var
zarko: TDeveloper
beginnen
zarko: = TMyObject. Creëren;
proberen
zarko. DoProgram;
Tenslotte
zarko. Vrij;
einde;
einde;

Dit is een voorbeeld van veilige geheugentoewijzing en deallocatiecode.

Enkele waarschuwende woorden: als u een Delphi-component dynamisch wilt instantiëren en deze later expliciet wilt vrijgeven, geef dan altijd nihil door als de eigenaar. Als u dit niet doet, kan dit onnodige risico's met zich meebrengen, evenals prestatie- en codeonderhoudsproblemen.

Naast het maken en vernietigen van objecten met behulp van de methoden Maken en Gratis, moet u ook heel voorzichtig zijn bij het gebruik van "externe" (bestanden, databases, enz.) Bronnen.
Laten we zeggen dat u een tekstbestand moet gebruiken. In een heel eenvoudig scenario, waarbij de AssignFile-methode wordt gebruikt om een ​​bestand op een schijf aan een bestand te koppelen variabele wanneer u klaar bent met het bestand, moet u CloseFile aanroepen om de bestandsingang te laten beginnen gebruikt. Hier heeft u geen expliciete oproep voor "gratis".

var
F: TextFile;
S: string;
beginnen
AssignFile (F, 'c: \ somefile.txt');
proberen
Readln (F, S);
Tenslotte
CloseFile (F);
einde;
einde;

Een ander voorbeeld is het laden van externe DLL's uit uw code. Telkens wanneer u LoadLibrary gebruikt, moet u FreeLibrary bellen:

var
dllHandle: THandle;
beginnen
dllHandle: = Loadlibrary ('MyLibrary. DLL ');
// doe iets met deze DLL
als dllHandle <> 0 dan FreeLibrary (dllHandle);
einde;

Hoewel met Delphi voor .NET de garbage collector (GC) de meeste geheugentaken beheert, is het mogelijk dat er geheugenlekken zijn in .NET-toepassingen. Hier is een artikelbespreking GC in Delphi voor .NET.

Naast het schrijven van modulaire geheugenveilige code, kan het voorkomen van geheugenlekken worden gedaan met behulp van een aantal van de beschikbare tools van derden. Delphi Memory Leak Fix Tools helpen u de Delphi-applicatie te vangen fouten zoals geheugenbeschadiging, geheugenlekken, geheugentoewijzingsfouten, initialisatiefouten bij variabelen, conflicten met variabele definitie, pointerfouten en meer.