Förstå och förhindra minnesläckor i Delphi

DelphiStöd för objektorienterad programmering är rik och kraftfull. Klasser och objekt möjliggör modulär kodprogrammering. Tillsammans med mer modulära och mer komplexa komponenter kommer mer sofistikerade och mer komplexa buggar.

Under utveckling applikationer i Delphi är (nästan) alltid kul, det finns situationer när du känner att hela världen är emot dig.

När du behöver använda (skapa) ett objekt i Delphi måste du frigöra minnet som det konsumerade (en gång inte längre behövs). Säkert kan försök / slutligen minnesskyddsblock hjälpa dig att förhindra minnesläckage; det är fortfarande upp till dig att skydda din kod.

Ett minne (eller resurs) läcker uppstår när programmet tappar förmågan att frigöra minnet det förbrukar. Upprepade minnesläckor gör att minnesanvändningen i en process växer utan gränser. Minnesläckor är ett allvarligt problem - om du har en kod som orsakar minnesläcka, i en applikation som körs 24/7 kommer applikationen att äta upp allt tillgängligt minne och slutligen få maskinen att sluta svara.

Det första steget för att undvika minnesläckor är att förstå hur de uppstår. Följande är en diskussion om några vanliga fallgropar och bästa metoder för att skriva Delphi-kod som inte läcker.

I de flesta (enkla) Delphi-applikationer, där du använder komponenterna (knappar, memos, redigeringar osv.) Som du släpper på ett formulär (vid designtid) behöver du inte bry dig för mycket om minneshantering. När komponenten har placerats på ett formulär blir formen dess ägare och kommer att frigöra minnet som tas av komponenten när formen stängs (förstörs). Formuläret är som ägare ansvarigt för minnesfördelning av de komponenter som det är värd. Kort sagt: komponenter i ett formulär skapas och förstörs automatiskt

I alla icke-triviala Delphi-applikationer kommer du att vilja inställning av Delphi-komponenter vid körning. Du kommer också att ha några av dina egna klasser. Låt oss säga att du har en klass TDeveloper som har en metod DoProgram. När du nu behöver använda TDeveloper-klassen skapar du en instans av klassen genom att ringa till Skapa metod (konstruktör). Metoden Skapa tilldelar minne för ett nytt objekt och returnerar en referens till objektet.

var
zarko: TDeveloper
Börja
zarko: = TMyObject. Skapa;
Zarko. DoProgram;
slutet;

Och här är en enkel minnesläcka!

Varje gång du skapar ett objekt måste du bortskaffa minnet som det ockuperade. För att frigöra minnet som ett tilldelat objekt måste du ringa till Fri metod. För att vara helt säker bör du också använda try / slutligen blockera:

var
zarko: TDeveloper
Börja
zarko: = TMyObject. Skapa;
Prova
Zarko. DoProgram;
till sist
Zarko. Fri;
slutet;
slutet;

Detta är ett exempel på säker minnesallokering och deallokaliseringskod.

Några varningsord: Om du vill dynamiskt instansera en Delphi-komponent och uttryckligen frigöra den någon gång senare, ska du alltid lämna nil som ägare. Om du inte gör det kan det orsaka onödiga risker samt problem med prestanda och kodunderhåll.

Förutom att skapa och förstöra objekt med hjälp av Create and Free-metoderna, måste du också vara mycket försiktig när du använder "externa" (filer, databaser, etc.) resurser.
Låt oss säga att du måste använda en textfil. I ett mycket enkelt scenario, där AssignFile-metoden används för att associera en fil på en disk med en fil variabel när du är klar med filen måste du ringa CloseFile för att frigöra filhandtaget för att börja Begagnade. Det är här du inte har ett uttryckligt samtal till "Gratis".

var
F: TextFile;
S: sträng;
Börja
AssignFile (F, 'c: \ somefile.txt');
Prova
Readln (F, S);
till sist
CloseFile (F);
slutet;
slutet;

Ett annat exempel inkluderar inläsning av externa DLL från din kod. När du använder LoadLibrary måste du ringa FreeLibrary:

var
dllHandle: THandle;
Börja
dllHandle: = Loadlibrary ('MyLibrary. DLL ');
// gör något med denna DLL
om dllHandle <> 0, då FreeLibrary (dllHandle);
slutet;

Även om avfallssamlaren (GC) hanterar de flesta minnesuppgifter med Delphi för .NET, är det möjligt att ha minnesläckor i .NET-applikationer. Här är en artikeldiskussion GC i Delphi för .NET.

Förutom att skriva modulär minnesäker kod kan du förhindra läckage av minnet genom att använda några av de tillgängliga tredjepartsverktygen. Delphi Memory Leak Fix Tools hjälper dig att fånga Delphi-applikationen fel såsom minneskorruption, minnesläckor, minnesallokeringsfel, variabla initieringsfel, variabla definitionskonflikter, pekfel och mer.