Fișierele în format DLL sunt deschise de programe speciale. Există 2 tipuri de formate DLL, fiecare dintre acestea fiind deschis de programe diferite. A deschide tipul dorit formatați, studiați descrierile fișierelor și descărcați unul dintre programele propuse.

Extensie de fișier .DLL

Programul HELPER.DLL vă va ajuta să găsiți și să instalați orice bibliotecă DLL lipsă sau deteriorată.

Fișierele în format DLL conțin setări de link pentru diverse resurse, folosit de program, de exemplu, pictograme. DLL-urile sunt destinate exclusiv sistemului de operare Windows. Pe alte sisteme de operare, astfel de fișiere pot fi deschise numai folosind emulatori (excepția o fac aplicațiile multiplatforme pentru Mac OS). Trebuie amintit că programele moderne nu acceptă fișiere pentru arhitectura pe 16 biți.

Masuri de precautie

În cele mai multe cazuri, utilizatorul nu trebuie să deschidă fișierele în format DLL, deoarece acestea sunt destinate exclusiv dezvoltatorilor. Editarea acestui fișier poate afecta negativ performanța programelor individuale și a sistemului de operare, din acest motiv trebuie să găsiți fișierul Dll și să faceți o copie a acestuia.

Programe pentru deschiderea fișierelor DLL

Vizualizați codul sursă

Una dintre cele mai comune moduri de a vizualiza o extensie Dll este . Programul are funcții încorporate pentru decompilarea unor fișiere, astfel încât să puteți depana fișierele dll și, cel mai important, este complet gratuit. Desigur, este imposibil să se garanteze afișarea corectă a codului pentru toate fișierele.

Ca alternativă, puteți utiliza decompilatorul dotPeek. De asemenea, este gratuit, dar poate funcționa numai cu programe scrise în C#.

Configurarea interfeței programului

Cel mai potrivit pentru acest scop. Cu acest program puteți schimba cu ușurință pictogramele, dialogurile sau puteți configura propria animație. Din păcate, programul este plătit chiar și pentru utilizare necomercială. Vă rugăm să rețineți că pot apărea probleme cu fișierele dimensiuni mari(aproximativ 1 GB sau mai mult).

Depanare

Cel mai într-un mod simplu este să utilizați Visual Studio de la Microsoft. Acesta este un instrument destul de funcțional, ale cărui capacități includ depanarea programului, dar va ajuta doar dacă fișierul nu este protejat.

Dacă trebuie doar să descărcați un DLL pentru a înlocui un fișier rupt (sau un DLL lipsește), atunci DLL-helper vă va ajuta aici - un program complet gratuit.

Pagini web dinamice

Există un alt format DLL - fișiere care generează cod pentru site-uri web. Astfel de biblioteci pot fi deschise în orice mediu de dezvoltare convenabil, de exemplu, Studio vizual. Browserul vă va ajuta să le testați în acțiune. Este mai bine să utilizați cele mai recente versiuni ale browserelor populare, altfel fișierul ar putea să nu se afișeze corect.

O pagină web care este creată automat în timpul accesării utilizatorului. Poate combina scripturi de pe server, cum ar fi Perl sau , care generează cod pentru paginile web.

Paginile web din fișierele cu extensii DLL sunt cel mai adesea stocate pe serverele web Microsoft IIS. Extensia DLL trebuie mapată la motorul de scripting de server corespunzător pentru ca pagina să fie procesată corect.

Un fișier de bibliotecă compilat care conține un set de proceduri și/sau drivere referite și executate de un program. Permite diverse programe acces public funcțiile sistemului prin biblioteci standard. Poate fi conectat dinamic într-un program în timp ce acesta rulează.

Sunt furnizate multe fișiere DLL (citiți DLL). sistem de operare Windows, altele sunt incluse în programele Windows. De asemenea, oferă diverse funcții software, cum ar fi conexiunea cu dispozitive externe atât semnal de intrare cât și de ieșire hard disk. Ele pot fi, de asemenea, referite prin aplicații pentru Mac multiplatformă.

Notă: Ștergerea sau modificarea conținutului unui fișier DLL poate cauza erori în programul care face referire la fișier. Prin urmare, fișierele DLL nu trebuie deschise sau editate.

FAQ

1. Deschideți fișierul zip pe care l-ați descărcat de pe site.
2. Extrageți fișierul DLL în orice locație de pe computer.
   • În continuare, vă sfătuim să plasați fișierul în folderul programului care solicită acest fișier. Asigurați-vă că utilizați un format de fișier DLL pe 32 de biți pentru un program pe 32 de biți și un format de fișier DLL pe 64 de biți pentru un program pe 64 de biți, altfel este posibil să primiți eroarea 0xc000007b.
3. Dacă pașii de mai sus nu vă rezolvă problema, plasați fișierul în folderul de sistem. În mod implicit, acest folder se află aici:
   • C:\Windows\System (Windows 95/98/Me),
     C:\WINNT\System32 (Windows NT/2000) sau
     C:\Windows\System32 (Windows XP, Vista, 7, 8, 8.1, 10).
4. În versiunea pe 64 de biți folderul Windows pentru fișierele DLL pe 32 de biți, locația implicită este aici:

C:\Windows\SysWOW64\ și pentru fișiere DLL pe 64 de biți
C:\Windows\System32\.

Asigurați-vă că reînregistrați totul fișierele existente(dar păstrați o copie de rezervă a fișierului original).

Reporniți computerul.

Dacă acest lucru nu rezolvă problema, încercați următorii pași pentru a adăuga fișierul în registry:

Pentru fișiere DLL pe 32 de biți în 32 de biți versiuni Windowsși pentru fișierele DLL pe 64 de biți pe Windows pe 64 de biți:

1. Deschideți un prompt de comandă ridicat.
   • Pentru a face acest lucru, faceți clic pe Start, Toate programele, selectați Accesorii, faceți clic dreapta pe Command Prompt, apoi faceți clic pe „Run as administrator”.
   • Dacă vi se cere să introduceți o parolă de administrator sau să confirmați, introduceți parola sau faceți clic pe Permite.
2. Apoi, tastați regsvr32 "filename".dll și apăsați Enter.

Pentru a adăuga fișiere DLL pe 32 de biți la registry pe Windows pe 64 de biți:

1. Deschideți un prompt de comandă ridicat, urmând pașii de mai sus.
2. • cd c:\windows\syswow64\
3. Apoi, tastați următoarele și apăsați Enter:
   • regsvr32 c:\windows\syswow64\"filename".dll

fișiere DLL Acestea sunt biblioteci dinamice care sunt folosite de multe programe de pe computer. Când dezinstalați sau actualizați unul dintre programele de pe computer, se poate întâmpla ca fișierele DLL instalate anterior în sistemul de operare să fie șterse din greșeală. Pe lângă această situație, de foarte multe ori sistemul nu poate detecta DLL-ul din cauza virușilor, fără licență software, care cu siguranță lasă o amprentă negativă asupra șederii lor pe computer.

Foarte des, fișierele DLL dispar din cauza unei întreruperi a conexiunii dintre program și sistemul de operare în cazurile în care utilizatorul transferă manual programul dintr-un folder în altul. Doar instrumentele automate și de sistem pentru eliminarea și instalarea programelor pe un PC pot asigura cea mai confortabilă utilizare a computerului și a sistemului de operare.

Biblioteca de link-uri dinamice

DLL (Engleză: Dynamic-link library) - bibliotecă dinamică

DLL (dynamic-link library) este un concept al sistemului de operare Microsoft Windows, o bibliotecă dinamică care permite utilizarea repetată de către diverse aplicații software, Conceptul de sistem de operare Microsoft Windows. DLL-urile includ, de asemenea, controale și drivere ActiveX.

Formatul de fișier DLL urmează aceleași convenții ca și formatul de fișier executabil EXE, combinând coduri, tabele și resurse.

Scopul introducerii DLL-urilor

Inițial s-a presupus că introducerea DLL-urilor ar permite organizarea eficientă a memoriei și spatiu pe disc, folosind o singură instanță de module de bibliotecă pentru multe aplicații. Acest lucru a fost deosebit de important pentru versiunile timpurii ale Microsoft Windows cu limitări severe de memorie.

Mai mult, sa urmărit îmbunătățirea eficienței dezvoltării și utilizării instrumentelor de sistem prin modularitate. Înlocuirea programelor DLL de la o versiune la alta ar fi trebuit să permită extinderea independentă a sistemului, fără a afecta aplicațiile. În plus, DLL-urile ar putea fi utilizate de diferite tipuri de aplicații - de exemplu, Microsoft Office, Microsoft Visual Studio, etc.

Mai târziu, ideea de modularitate a crescut în conceptul de controale ActiveX.

De fapt, beneficiile complete ale implementării DLL-urilor nu au fost atinse din cauza unui fenomen numit iadul DLL. Iadul DLL apare atunci când mai multe aplicații necesită diferite versiuni DLL-biblioteci datorită compatibilităţii lor incomplete, ceea ce duce la conflicte grave. Când sistemul a crescut la o anumită dimensiune, numărul de DLL-uri a început să depășească multe mii, nu toate erau pe deplin fiabile și compatibile, iar conflicte precum iadul DLL au început să apară foarte des, reducând drastic fiabilitatea generală a sistemului. Versiuni ulterioare Microsoft Windows a început să fie permis utilizare paralelă diferite versiuni ale DLL, care au anulat beneficiile principiului original de modularitate.

Sunteți aici pentru că aveți un fișier care are o extensie de fișier care se termină în .dll. Fișierele cu extensia .dll pot fi lansate numai de anumite programe. Este posibil ca .dll-urile să fie fișiere de date și nu documente sau medii, ceea ce înseamnă că nu sunt menite deloc să fie vizualizate.

ce este un fișier .dll ?

Aceste fișiere DLL sunt cunoscute și ca fișiere Dynamic Link Library, iar conținutul fișierului atașat cu extensia .dll este un set de resurse compilate, cum ar fi directive, proceduri și biblioteci de drivere, care sunt necesare pentru aplicațiile Windows încorporate și programe de la terți, care au fost dezvoltate pentru Microsoft Windows. Aceste fișiere DLL permit programelor Windows să resurse partajateîn biblioteci compilate cu alte aplicații. În timpul execuției, unele dintre aceste aplicații pot fi legate la aceste DLL-uri de resurse. Cele mai multe dintre aceste fișiere DLL sunt deja incluse sisteme Microsoft Windows, deși unele programe oferă propriile DLL-uri de resurse după instalare. Unele dintre aceste fișiere DLL facilitează comunicarea între sistemul Windows, sistemul încorporat sau aplicații de la terțiși resursele driver necesare pentru externe și dispozitive interne intrare ieșire.

cum se deschide un fișier .dll?

Lansați fișierul .dll sau orice alt fișier de pe computer făcând dublu clic pe el. Dacă asociațiile dvs. de fișiere sunt configurate corect, aplicația care este destinată să vă deschidă fișierul .dll o va deschide. Poate fi necesar să descărcați sau să cumpărați aplicația corectă. De asemenea, este posibil să aveți aplicația corectă pe computer, dar fișierele .dll nu sunt încă asociate cu aceasta. În acest caz, când încercați să deschideți un fișier .dll, puteți spune Windows care aplicație este cea corectă pentru acest fișier. De atunci, deschiderea fișierului .dll va deschide aplicația corectă.

aplicații care deschid fișierul .dll

Sistem de operare Microsoft Windows

Microsoft Windows Sistem de operare platformele foloseau cel mai mult fișiere cu extensia .ANI, un format de fișier grafic folosit pentru cursoarele animate ale mouse-ului, care sunt, de asemenea, definite ca Windows Animated Cursor. Aceste fișiere au aceleași funcții cu formatul de fișier CUR sau mai bine cunoscut sub numele de Cursor Static; distincția sa este că fiind un cursor animat cu utilizarea șirurilor de imagini pentru a afișa animația. Formatul se bazează pe formatul de fișier Microsoft RIFF, care este utilizat ca stocare pentru păstrarea cadrelor individuale, care sunt pictograme tipice Windows ale animației. Acest tip de fișier este de obicei integrat într-o temă personalizată pentru desktop și este util pentru personalizarea sistemului CPU. Animația sa finală este concepută cu niște cadre cu pictograme care sunt folosite pentru a afișa o singură imagine după alta pentru a genera animație. În ciuda numărului de cadre care utilizează formatul pictogramei, o parte din datele stocate în fișierul cursor animat gestionează ordinea pasului, lungimea, titlul și autorul animației.

un cuvânt de avertisment

Aveți grijă să nu redenumiți extensia fișierelor .dll sau a altor fișiere. Acest lucru nu va schimba tipul fișierului. Numai program special Pentru a converti, puteți schimba fișierul de la un tip de fișier la altul.

care este extensia fisierului?

O extensie de fișier este un set de trei sau patru caractere la sfârșitul unui nume de fișier, în acest caz,  .dll. Extensiile de fișier vă spun ce tip de fișier este și spun Windows ce programe poate deschide. Windows asociază adesea un program implicit pentru fiecare extensie de fișier, astfel încât atunci când faceți dublu clic pe un fișier, programul se lansează automat. Chiar dacă un program nu se mai află pe computerul dvs., este posibil să primiți uneori un mesaj de eroare atunci când încercați să deschideți fișierul în cauză.

Mă bucur să te văd pe blogul meu!

Găsit în nostru DLL de computer fișiere și habar nu ai ce sunt? Vă voi împărtăși informații. Fără ele, majoritatea programelor și sistemul de operare în ansamblu nu vor putea funcționa. Vrei să afli mai multe? Nu rata articolul meu.

Explicaţie

Această abreviere înseamnă „Dynamic Link Library”, iar în limba noastră - „dynamic link library” sau, mai des, „dynamic link library”. Este instalat implicit pe sistemul de operare Windows și anterior și pe IBM OS/2, până când a încetat să mai existe. Biblioteca este destinată utilizării repetate de către diverse programe software.

DLL conține informații importante: despre configurația sistemului, compatibilitatea dispozitivelor, comenzile pentru acestea funcţionare corectă etc. Toate acestea sunt stocate în fișiere cu aceeași extensie de nume sau .drv pentru mai multe drivere de sistem, .cpl - pentru fișierele panoului de control sau în .ocx, dacă vorbim de biblioteci care conțin framework-ul ActiveX.

Obiectele .dll conțin cod și date care pot fi utilizate de mai multe programe în același timp. Conținutul lor este similar cu tipul de fișier EXE. Apropo, au chiar și același format: Portable Executable (PE) pentru aplicațiile Windows pe 32 și 64 de biți și New Executable (NE) pentru cele pe 16 biți.

Multe programe pe care le instalăm au ​​deja astfel de fișiere în setul lor. În caz contrar, le folosesc pe cele care sunt în sistemul de operare.

Biblioteci dinamice în practică

În teorie, totul pare clar. Dar pentru a înțelege esența subiectului conversației noastre, este necesar să-l vedem din partea practică. Fără el, programele nu pot funcționa pentru că nu știu cum să o facă.

Iată un exemplu de bază. Pentru ca caracterele pe care le introduceți să înceapă să apară pe o foaie goală de hârtie în Office Word, aveți nevoie de componente de bibliotecă, deoarece sistemul de operare în sine nu știe ce înseamnă cutare sau cutare tastă pe care apăsați.

Chiar și atunci când doar porniți computerul și nu ați avut încă timp să faceți nimic, biblioteca este deja activă: v-a arătat ora și data, a deschis programe la pornire, a construit designul desktopului, a studiat informații despre configurația sistemului de operare, etc. În plus, modul în care sistemul comunică cu mouse-ul, tastatura, imprimanta și alte echipamente, explică, de asemenea, DLL.

Avantajele DLL-urilor

Pentru ce sunt bibliotecile dinamice? Au fost create cu scopul de a:

Iadul pentru biblioteci

Încă nu a fost posibil să se realizeze pe deplin avantajele descrise mai sus. Faptul este că software-ul poate să nu necesite complet în același timp versiuni compatibile biblioteci. Din această cauză, apar defecțiuni în funcționarea acestuia. În plus, din cauza conflictelor, fiabilitatea sistemului de operare în ansamblu scade. Acest fenomen se numește „iad DLL” (dacă cineva nu știe, ultimul cuvânt este tradus ca „iad”).

Cum îl vede utilizatorul?

Să presupunem că nu ați actualizat niciodată aceste biblioteci pe computer și nu ați instalat un joc care a fost lansat acum aproximativ 5 ani. Funcționează bine pentru tine. Apoi ai descoperit că cea mai recentă parte a jocului a fost lansată recent și ai instalat-o și tu.

Cu toate acestea, al doilea refuză deja să înceapă. Ea și-a însoțit neascultarea cu un mesaj care spunea că a existat o eroare DLL, fișierul lipsește. Aceasta înseamnă că componentele de pe computer necesare pentru a-l rula nu funcționează sau lipsesc complet.

Acest lucru se poate datora indicării incorecte a adâncimii de biți sau a versiunii de sistem în timpul procesului de instalare a jocului sau din alte motive. La urma urmei, programele și jocurile pot suprascrie fișierele de bibliotecă (vezi ultimul avantaj), drept urmare, uneori, acest software sau acela refuză să funcționeze.

Soluţie

Pentru a preveni astfel de situații să apară, ultimele generații de Windows au introdus tehnologia de asamblare Side-by-side. Permite utilizarea în paralel versiuni diferite biblioteci. Adevărat, această inovație contravine principiului modularității, care a fost inițial un avantaj.

În cazurile în care sistemul emite probleme Eroare DLL, puteți încerca să descărcați și să instalați componente individuale actualizate sau întregul pachet. Apropo, puteți urmări aplicațiile care utilizează fișierele de bibliotecă folosind utilitare speciale, de exemplu, Dependența Walker.

Asta e tot.

Dacă găsiți ceva neclar pe computer sau doar plictisit, reveniți. Am mereu articole utile ;)

De la naștere (sau puțin mai târziu), sistemul de operare Windows a folosit DLL-uri (Dynamic Link Libraries), care conțineau implementări ale celor mai frecvent utilizate funcții. Succesorii Windows - NT și Windows 95, precum și OS/2 - depind și ei de DLL pentru o mare parte din funcționalitatea lor.

Să ne uităm la o serie de aspecte ale creării și utilizării DLL-urilor:

• cum să legați static DLL-urile;
• cum să încărcați dinamic DLL-uri;
• cum se creează DLL-uri;
• cum să creați extensii MFC DLL.

Folosind DLL-uri

Aproape imposibil de creat aplicație Windows, care nu ar folosi DLL-uri. DLL conține toate funcțiile API-ului Win32 și nenumărate alte funcții ale sistemelor de operare Win32.

În general, DLL-urile sunt pur și simplu colecții de funcții colectate în biblioteci. Cu toate acestea, spre deosebire de verii lor statici (fișiere .lib), DLL-urile nu sunt legate direct la executabile folosind un linker. Fișierul executabil conține doar informații despre locația lor. În momentul execuției programului, întreaga bibliotecă este încărcată. Acest lucru permite diferitelor procese să partajeze aceleași biblioteci în memorie. Această abordare vă permite să reduceți memoria necesară pentru mai multe aplicații care utilizează multe biblioteci partajate, precum și să controlați dimensiunea fișierelor EXE.

Cu toate acestea, dacă biblioteca este folosită de o singură aplicație, este mai bine să o faceți una obișnuită, statică. Desigur, dacă funcțiile incluse în acesta vor fi utilizate doar într-un singur program, puteți pur și simplu să introduceți fișierul text sursă corespunzător în acesta.

Cel mai adesea, proiectul este conectat la DLL static, sau implicit, la momentul link-ului. Încărcarea DLL-urilor în timpul execuției programului este controlată de sistemul de operare. Cu toate acestea, DLL-urile pot fi încărcate fie explicit, fie dinamic în timp ce aplicația rulează.

Importați biblioteci

Când conectați static un DLL, numele fișierului .lib este determinat printre alți parametri ai editorului de linkuri în Linie de comanda sau din fila Link din caseta de dialog Project Settings din Developer Studio. Cu toate acestea, fișierul .lib folosit atunci când conectați implicit un DLL,- aceasta nu este o bibliotecă statică obișnuită. Astfel de fișiere .lib sunt numite importa biblioteci(import biblioteci). Ele nu conțin codul bibliotecii în sine, ci doar legături către toate funcțiile exportate din fișierul DLL în care este stocat totul. Ca urmare, bibliotecile de import tind să aibă dimensiune mai mică decât fișierele DLL. Vom reveni la cum să le creăm mai târziu. Acum să ne uităm la alte probleme legate de includerea implicită a bibliotecilor dinamice.

Negocierea interfeței

Când utilizați propriile biblioteci sau biblioteci dezvoltatori independenți Va trebui să acordați atenție potrivirii apelului de funcție cu prototipul său.

Dacă lumea ar fi perfectă, atunci programatorii nu ar trebui să-și facă griji cu privire la potrivirea interfețelor cu funcții atunci când conectează biblioteci - ar fi toate la fel. Cu toate acestea, lumea este departe de a fi perfectă și multe programe mari scris folosind diverse biblioteci fără C++.

În mod implicit, Visual C++ se conformează interfețelor cu funcții conform regulilor C++. Aceasta înseamnă că parametrii sunt împinși pe stivă de la dreapta la stânga, program de apelare este responsabil pentru eliminarea acestora din stivă la ieșirea din funcție și extinderea numelui acesteia. Manipularea numelor permite linkerului să facă distincția între funcțiile supraîncărcate, de exemplu. funcţionează cu aceleaşi nume, dar liste diferite argumente. Cu toate acestea, vechea bibliotecă C nu are funcții extinse cu nume.

Deși toate celelalte reguli pentru apelarea unei funcții în C sunt identice cu regulile pentru apelarea unei funcții în C++, numele funcțiilor nu sunt extinse în bibliotecile C. Sunt precedate doar de un caracter de subliniere (_).

Dacă trebuie să conectați o bibliotecă C la o aplicație C++, toate funcțiile din această bibliotecă vor trebui declarate ca externe în format C:

Extern "C" int MyOldCFunction(int myParam);

Declarațiile funcțiilor bibliotecii sunt de obicei plasate în fișierul antet al bibliotecii, deși anteturile majorității bibliotecilor C nu sunt concepute pentru a fi utilizate în proiecte C++. În acest caz, trebuie să creați o copie a fișierului antet și să includeți modificatorul extern „C” în declarația tuturor funcțiilor de bibliotecă utilizate. Modificatorul extern „C” poate fi aplicat și unui bloc întreg, la care vechiul fișier antet C este conectat folosind directiva #tinclude. Astfel, în loc să modificați fiecare funcție separat, vă puteți descurca cu doar trei linii:

Extern „C” ( #include „MyCLib.h”)

Programele pentru versiunile mai vechi de Windows au folosit și convenții de apelare a funcției limbajul PASCAL pentru funcțiile API Windows. Programele noi ar trebui să utilizeze modificatorul winapi, care se convertește în _stdcall. Deși acest lucru nu este interfata standard funcțiile C sau C++, dar tocmai acesta este folosit pentru a accesa Funcții Windows API. Cu toate acestea, de obicei toate acestea sunt deja luate în considerare în anteturile standard Windows.

Încărcarea unui DLL implicit

Când o aplicație pornește, încearcă să găsească toate fișierele DLL atașate implicit aplicației și să le plaseze în zona RAM ocupată de proces. Sistemul de operare caută fișiere DLL în următoarea secvență.

• Directorul în care se află fișierul EXE.
• Directorul curent al procesului.
• Directorul de sistem Windows.

Dacă DLL-ul nu este găsit, aplicația afișează o casetă de dialog care indică absența acestuia și căile căutate. Procesul se oprește apoi.

Dacă bibliotecă necesară găsit, este plasat în RAM proces, unde rămâne până la finalizare. Aplicația poate accesa acum funcțiile conținute în DLL.

Încărcarea și descărcarea dinamică a DLL-urilor

În loc să se conecteze în mod dinamic Windows la DLL atunci când aplicația este încărcată pentru prima dată în memorie, puteți conecta programul la modulul bibliotecii în timpul execuției (cu această metodă, nu este nevoie să utilizați biblioteca de import când creați aplicația). Mai exact, puteți determina ce DLL-uri sunt disponibile pentru utilizator sau puteți permite utilizatorului să aleagă ce DLL-uri vor fi încărcate. În acest fel, puteți utiliza DLL-uri diferite care implementează aceleași funcții pentru a efectua acțiuni diferite. De exemplu, o aplicație concepută pentru transferul independent de date va putea decide în timpul rulării dacă să încarce un DLL pentru protocolul TCP/IP sau pentru un alt protocol.

Încărcarea unui DLL obișnuit

Primul lucru pe care trebuie să-l faceți când încărcați dinamic un DLL este să plasați modulul bibliotecii în memoria de proces. Această operațiune realizat folosind funcția ::LoadLibrary, care are un singur argument - numele modulului încărcat. Fragmentul de program corespunzător ar trebui să arate astfel:

HINSTANȚĂ hMyDll; :: if((hMyDll=:: LoadLibrary("MyDLL"))==NULL) ( /* nu a reușit încărcarea DLL */ ) else ( /* aplicația are permisiunea de a utiliza funcții DLL prin hMyDll */ )

Windows consideră că extensia de fișier bibliotecă standard este .dll, cu excepția cazului în care specificați o extensie diferită. Dacă numele fișierului include și o cale, atunci numai acea cale va fi folosită pentru a căuta fișierul. În caz contrar, Windows va căuta fișierul în același mod ca și DLL-urile incluse implicit, pornind de la directorul din care este încărcat fișierul exe și continuând în funcție de valoarea PATH.

Când Windows găsește fișierul, calea sa completă va fi comparată cu calea DLL-urilor deja încărcate de proces. Dacă se găsește o identitate, în loc să descărcați o copie a aplicației, este returnat un handle către biblioteca deja inclusă.

Dacă fișierul este găsit și biblioteca este încărcată cu succes, funcția ::LoadLibrary returnează mânerul său, care este folosit pentru a accesa funcțiile bibliotecii.

Înainte de a utiliza funcțiile bibliotecii, trebuie să obțineți adresa acestora. Pentru a face acest lucru, trebuie mai întâi să utilizați directiva typedef pentru a defini tipul unui indicator de funcție și a defini o variabilă de acest tip nou, de exemplu:

// tipul PFN_MyFunction va declara un pointer către o funcție care // duce un pointer către un buffer de caractere și produce o valoare tastați int typedef int (WINAPI *PFN_MyFunction)(char *); ::PFN_MyFunction pfnMyFunction;

Apoi ar trebui să obțineți un descriptor de bibliotecă, cu ajutorul căruia puteți determina adresele funcțiilor, de exemplu, adresa unei funcții numită MyFunction:

HMyDll=::LoadLibrary(„MyDLL”); pfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll,"MyFunction"); :: int iCode=(*pfnMyFunction)("Bună ziua");

Adresa funcției este determinată folosind funcția ::GetProcAddress, ar trebui să i se transmită numele bibliotecii și numele funcției. Acesta din urmă trebuie transmis în forma în care este exportat din DLL.

De asemenea, puteți face referire la o funcție prin numărul ordinal cu care este exportată (în acest caz, trebuie folosit un fișier def pentru a crea biblioteca, despre care va fi discutat mai târziu):

PfnMyFunction=(PFN_MyFunction)::GetProcAddress(hMyDll, MAKEINTRESOURCE(1));

După terminarea lucrului cu biblioteca de legături dinamice, aceasta poate fi descărcată din memoria procesului folosind funcția:: FreeLibrary:

::FreeLibrary(hMyDll);

Se încarcă extensiile MFC în biblioteci dinamice

Când încărcați extensii MFC pentru DLL-uri (discutate în detaliu mai jos) în loc de funcții LoadLibraryȘi FreeLibrary sunt utilizate funcții AfxLoadLibraryȘi AfxFreeLibrary. Acestea din urmă sunt aproape identice cu funcțiile Win32 API. În plus, garantează doar că structurile MFC inițializate de extensia DLL nu au fost corupte de alte fire.

Resurse DLL

Încărcarea dinamică se aplică și resurselor DLL pe care MFC le folosește pentru a încărca resursele aplicației standard. Pentru a face acest lucru, mai întâi trebuie să apelați funcția LoadLibraryși plasați DLL-ul în memorie. Apoi, folosind funcția AfxSetResourceHandle trebuie să pregătiți fereastra programului pentru a primi resurse din biblioteca nou încărcată. În caz contrar, resursele vor fi încărcate din fișierele atașate la fișierul executabil al procesului. Această abordare este convenabilă dacă trebuie să utilizați seturi diferite de resurse, de exemplu pentru diferite limbi.

Cometariu. Folosind funcția LoadLibrary poate fi încărcat și în memorie fișiere executabile(nu le rulați!). Mânerul modulului executabil poate fi folosit atunci când se apelează funcții GăsițiResurseȘi LoadResource pentru a căuta și descărca resurse pentru aplicații. Modulele sunt, de asemenea, descărcate din memorie folosind funcția FreeLibrary.

Exemplu de DLL obișnuit și metode de încărcare

Să dăm sursă bibliotecă de link-uri dinamice, care se numește MyDLL și conține o funcție MyFunction, care pur și simplu imprimă un mesaj.

Mai întâi, o constantă macro este definită în fișierul antet EXPORT. Folosirea acestui cuvânt cheie atunci când definiți o funcție într-o bibliotecă de legături dinamice îi spune linkerului că funcția este disponibilă pentru utilizare de către alte programe, ceea ce face ca aceasta să fie inclusă în biblioteca de import. În plus, o astfel de funcție, la fel ca o procedură de fereastră, trebuie definită folosind constanta SUNĂ DIN NOU:

MyDLL.h#define EXPORT extern "C" __declspec (dllexport) EXPORT int CALLBACK MyFunction(char *str);

Fișierul bibliotecii este, de asemenea, ușor diferit de fișiere obișnuiteîn C pentru Windows. Conține în loc de o funcție WinMain exista o functie DllMain. Această funcție este folosită pentru a efectua inițializarea, care va fi discutată mai târziu. Pentru ca biblioteca să rămână în memorie după ce este încărcată, astfel încât funcțiile sale să poată fi apelate, valoarea sa returnată trebuie să fie TRUE:

MyDLL.c #include #include "MyDLL.h" int WINAPI DllMain(HINSTANCE hInstance, DWORD fdReason, PVOID pvReserved) ( return TRUE; ) EXPORT int CALLBACK MyFunction(char *str) ( MessageBox(NULL,str,"Function from DLL",MB_OK); întoarce 1)

După traducerea și conectarea acestor fișiere, apar două fișiere - MyDLL.dll (biblioteca de linkuri dinamice în sine) și MyDLL.lib (biblioteca sa de import).

Exemplu de conexiune DLL implicită după aplicație

Să arătăm acum codul sursă aplicare simplă care utilizează funcția MyFunction din biblioteca MyDLL.dll:

#include #include "MyDLL.h" int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) ( int iCode=MyFunction("Hello"); return 0; )

Acest program arată ca un program Windows obișnuit, care este exact ceea ce este. Cu toate acestea, trebuie remarcat faptul că în textul său sursă, pe lângă apelarea funcției MyFunction din biblioteca DLL, este inclus și fișierul antet al acestei biblioteci, MyDLL.h. De asemenea, este necesar să vă conectați la acesta în etapa de compunere a aplicării biblioteca de import MyDLL.lib (procesul de conectare implicit a unui DLL la un modul executabil).

Este extrem de important să înțelegeți că codul MyFunction în sine nu este inclus în fișierul MyApp.exe. În schimb, conține pur și simplu un link către fișierul MyDLL.dll și un link către funcția MyFunction care se află în acel fișier. Fișierul MyApp.exe necesită fișierul MyDLL.dll pentru a rula.

Fișierul antet MyDLL.h este inclus în fișierul sursă al programului MyApp.c în același mod în care fișierul windows.h este inclus acolo. Includerea bibliotecii de import MyDLL.lib pentru conectare este aceeași cu includerea tuturor bibliotecilor de import Windows acolo. Când MyApp.exe rulează, se conectează la MyDLL.dll în același mod ca toate bibliotecile standard de linkuri dinamice Windows.

Exemplu de încărcare dinamică a unui DLL de către o aplicație

Să oferim acum codul sursă complet pentru o aplicație simplă care utilizează funcția MyFunction din biblioteca MyDLL.dll, folosind încărcare dinamică biblioteci:

#include typedef int (WINAPI *PFN_MyFunction)(char *); int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) ( HINSTANCE hMyDll; if((hMyDll=LoadLibrary("MyDLL"))==NULL) returnează 1; PFN_fNPFMFnction; Funcție)G etProcAddress( hMyDll ,"MyFunction"); int iCode=(*pfnMyFunction)("Salut");

Crearea unui DLL

Acum, după ce ne-am familiarizat cu principiile de funcționare a DLL-urilor în aplicații, să vedem cum să le creăm. Când dezvoltați o aplicație, este recomandabil să plasați într-un DLL funcțiile care sunt accesate de mai multe procese. Acest lucru permite o utilizare mai eficientă a memoriei în Windows.

Cel mai simplu mod de a crea proiect nou DLL folosind expertul AppWizard, care efectuează automat multe operațiuni. Pentru DLL-uri simple, cum ar fi cele discutate în acest capitol, trebuie să selectați tipul de proiect Win32 Dynamic-Link Library. Noului proiect i se vor oferi toate setările necesare pentru a crea DLL. Fișiere textele sursă va trebui să-l adăugați manual în proiect.

Dacă intenționați să profitați din plin de funcționalitatea MFC, cum ar fi documentele și vizualizările, sau intenționați să creați un server de automatizare OLE, este mai bine să selectați tipul de proiect MFC AppWizard (dll). În acest caz, pe lângă alocarea parametrilor proiectului pentru conectarea bibliotecilor dinamice, vrăjitorul va face câteva muncă în plus. Legăturile necesare către bibliotecile MFC și fișierele sursă care conțin o descriere și o implementare în DLL a unui obiect de clasă de aplicație derivat din CWinApp.

Uneori este convenabil să creați mai întâi un proiect precum MFC AppWizard (dll) ca aplicație de testare, apoi să creați DLL-ul ca parte a acestuia. Ca rezultat, DLL-ul va fi creat automat dacă este necesar.

Funcția DllMain

Majoritatea DLL-urilor sunt pur și simplu colecții de funcții esențial independente care sunt exportate și utilizate de aplicații. Pe lângă funcțiile destinate exportului, fiecare DLL are o funcție DllMain. Această funcție este concepută pentru a inițializa și curăța un DLL. A înlocuit funcțiile LibMainȘi WEP, folosit în versiunile anterioare de Windows. Structura cea mai simplă funcție DllMain ar putea arăta astfel, de exemplu:

BOOL WINAPI DllMain (HANDLE hInst,DWORD dwReason, LPVOID IpReserved) ( BOOL bAllWentWell=TRUE; comutator (dwReason) (case DLL_PROCESS_ATTACH: // Inițializarea procesului. break; case DLL_THREAD_ATTACH: // Thread_THREAD_ATTACH: // Inițializare Thread_break / Curățare caz DLLETACH:THREAD/. Structuri de fire de execuție DLL_PROCESS_DETACH: // Ștergerea structurilor de proces ) if(bAllWentWell) return TRUE;

Funcţie DllMain numit în mai multe cazuri. Motivul apelării este determinat de parametrul dwReason, care poate lua una dintre următoarele valori.

Prima dată când un proces încarcă un DLL, funcția este apelată DllMain cu dwReason egal cu DLL_PROCESS_ATTACH. De fiecare dată când un proces creează un fir nou, DllMainO este apelat cu dwReason egal cu DLL_THREAD_ATTACH (cu excepția primului thread, deoarece în acest caz dwReason este egal cu DLL_PROCESS_ATTACH).

După ce procesul a terminat de lucrat cu DLL, funcția DllMain apelat cu parametrul dwReason egal cu DLL_PROCESS_DETACH. Când un fir este distrus (cu excepția primului), dwReason va fi egal cu DLL_THREAD_DETACH.

Toate operațiunile de inițializare și curățare pentru procesele și firele de execuție de care are nevoie DLL-ul trebuie să fie efectuate pe baza valorii dwReason, așa cum se arată în exemplul anterior. Inițializarea procesului este de obicei limitată la alocarea resurselor partajate între fire, cum ar fi încărcarea fișierelor partajate și inițializarea bibliotecilor. Inițializarea firului de execuție este utilizată pentru a configura modurile care sunt unice pentru acest curent, de exemplu pentru a inițializa memoria locală.

Un DLL poate conține resurse care nu sunt deținute de aplicația care o apelează. Dacă funcțiile DLL funcționează pe resurse DLL, ar fi evident util să stocați un handle hInst undeva în afara drumului și să îl utilizați atunci când încărcați resurse din DLL. Pointerul IpReserved este rezervat pentru intern folosind Windows. Prin urmare, cererea nu ar trebui să-l revendice. Nu poți decât să-i verifici semnificația. Dacă DLL-ul a fost încărcat dinamic, acesta va fi NULL. Când se încarcă static, acest indicator va fi diferit de zero.

Dacă are succes, funcția DllMain ar trebui să returneze TRUE. Dacă apare o eroare, este returnat FALSE și acțiunea ulterioară este terminată.

Cometariu. Dacă nu vă scrieți propria funcție DllMain(), compilatorul va include versiune standard, care pur și simplu returnează TRUE.

Exportarea funcțiilor din DLL-uri

Pentru ca aplicația să poată accesa funcții bibliotecă dinamică, fiecare dintre ele trebuie să ocupe un rând în tabelul cu funcțiile DLL exportate. Există două moduri de a adăuga o funcție la acest tabel în timpul compilării.

metoda __declspec(dllexport).

Puteți exporta o funcție dintr-un DLL prefixând descrierea acesteia cu modificatorul __declspec (dllexport). În plus, MFC include mai multe macrocomenzi care definesc __declspec (dllexport), inclusiv AFX_CLASS_EXPORT, AFX_DATA_EXPORT și AFX_API_EXPORT.

Metoda __declspec nu este folosită la fel de des ca a doua metodă, care funcționează cu fișiere de definire a modulelor (.def) și permite un control mai bun asupra procesului de export.

Fișiere de definire a modulului

Sintaxa pentru fișierele .def din Visual C++ este destul de simplă, în principal pentru că opțiunile complexe utilizate în versiunile anterioare de Windows nu se mai aplică în Win32. După cum va fi clar din următorul exemplu simplu, fișierul .def conține numele și descrierea bibliotecii, precum și o listă de funcții exportate:

MyDLL.def BIBLIOTECĂ „MyDLL” DESCRIERE „MyDLL - exemplu de bibliotecă DLL” EXPORTĂ MyFunction @1

În linia de export a funcției, puteți indica numărul de serie plasând simbolul @ în fața acestuia. Acest număr va fi folosit atunci când contactați GetProcAddress(). De fapt, compilatorul atribuie numere de serie toate obiectele exportate. Cu toate acestea, modul în care face acest lucru este oarecum imprevizibil, cu excepția cazului în care atribuiți aceste numere în mod explicit.

Puteți utiliza parametrul NONAME în șirul de export. Împiedică compilatorul să includă numele funcției în tabelul de export DLL:

MyFunction @1 NONAME

Uneori, acest lucru poate economisi mult spațiu în fișierul DLL. Aplicațiile care folosesc biblioteca de import pentru a lega implicit DLL-urile nu vor „observa” diferența, deoarece conectarea implicită utilizează numerele de secvență automat. Aplicațiile care încarcă DLL-uri în mod dinamic vor trebui să treacă GetProcAddress numărul de ordine, nu numele funcției.

Când utilizați cele de mai sus, fișierul def care descrie funcțiile DLL exportate poate să nu fie, de exemplu, astfel:

#define EXPORT extern "C" __declspec (dllexport) EXPORT int CALLBACK MyFunction(char *str); un astfel de: extern "C" int CALLBACK MyFunction(char *str);

Exportul claselor

Crearea unui fișier .def pentru a exporta chiar și clase simple dintr-o bibliotecă dinamică poate fi destul de dificilă. Va trebui să exportați în mod explicit fiecare funcție care poate fi utilizată de o aplicație externă.

Dacă te uiți la fișierul de alocare a memoriei implementat în clasă, vei observa câteva caracteristici foarte neobișnuite. Rezultă că există constructori și destructori impliciti, funcții declarate în macro-urile MFC, în special _DECLARE_MESSAGE_MAP, precum și funcții care sunt scrise de programator.

Deși este posibil să exportați fiecare dintre aceste funcții în mod individual, există o modalitate mai ușoară. Dacă utilizați macromodificatorul AFX_CLASS_EXPORT într-o declarație de clasă, compilatorul însuși se va ocupa de exportul funcțiilor necesare care permit aplicației să folosească clasa conținută în DLL.

DLL de memorie

Spre deosebire de bibliotecile statice, care devin în esență parte a codului aplicației, bibliotecile de link dinamic din versiunile pe 16 biți ale Windows au tratat memoria puțin diferit. Sub Win 16, memoria DLL a fost localizată în afara spațiului de adrese de activitate. Plasarea bibliotecilor dinamice în memoria globală a făcut posibilă partajarea acestora între diferite sarcini.

În Win32, un DLL se află în zona de memorie a procesului care îl încarcă. Fiecare proces primește o copie separată a memoriei DLL „globale”, care este reinițializată de fiecare dată când o încarcă un nou proces. Aceasta înseamnă că biblioteca dinamică nu poate fi partajată, în memorie partajată, așa cum a fost în Winl6.

Cu toate acestea, efectuând o serie de manipulări complicate pe segmentul de date al unui DLL, este posibil să se creeze o zonă de memorie partajată pentru toate procesele care utilizează DLL.

Să presupunem că avem o matrice de numere întregi care ar trebui să fie utilizate de toate procesele care încarcă un anumit DLL. Acesta poate fi programat după cum urmează:

#pragma data_seg(".myseg") int sharedlnts ; // alte variabile uz comun#pragma data_seg() #pragma comment(lib, "msvcrt" "-SECTION:.myseg,rws");

Toate variabilele declarate între directivele #pragma data_seg() sunt plasate în segmentul.myseg. Directiva #pragma comment() nu este un comentariu obișnuit. Acesta indică bibliotecii C runtime să marcheze noua sectiune ca citit, scris și partajabil.

Compilare DLL completă

Dacă proiectul de bibliotecă dinamică este creat folosind AppWizard și fișierul .def este modificat în consecință, acest lucru este suficient. Dacă creați fișiere de proiect manual sau prin alte mijloace fără ajutorul AppWizard, ar trebui să includeți parametrul /DLL pe linia de comandă a editorului de linkuri. Acest lucru va crea un DLL în loc de un executabil independent.

Dacă există o linie LIBRART în fișierul .def, nu trebuie să specificați în mod explicit parametrul /DLL pe linia de comandă a editorului de legături.

Există o serie de opțiuni disponibile pentru MFC regimuri speciale referitor la utilizarea bibliotecii dinamice a bibliotecilor MFC. Următoarea secțiune este dedicată acestei probleme.

DLL și MFC

Programatorul nu este obligat să folosească MFC atunci când creează biblioteci dinamice. Cu toate acestea, utilizarea MFC deschide o serie de posibilități foarte importante.

Există două niveluri de utilizare a structurii MFC într-un DLL. Prima este o bibliotecă dinamică obișnuită bazată pe MFC, DLL MFC(DLL MFC obișnuit). Poate folosi MFC, dar nu poate trece pointeri către obiecte MFC între DLL și aplicații. Al doilea nivel este implementat în extensii MFC dinamice(DLL extensii MFC). Utilizarea acestui tip de bibliotecă dinamică necesită un efort suplimentar de configurare, dar permite ca indicatorii către obiectele MFC să fie schimbate liber între DLL și aplicație.

DLL-uri MFC obișnuite

DLL-urile MFC obișnuite vă permit să utilizați MFC în biblioteci dinamice. Cu toate acestea, aplicațiile care accesează astfel de biblioteci nu trebuie neapărat să fie construite pe MFC. DLL-urile obișnuite pot folosi MFC în orice mod, inclusiv prin crearea de noi clase în DLL bazate pe clase MFC și exportarea lor în aplicații.

Cu toate acestea, DLL-urile obișnuite nu pot schimba pointeri către clase derivate din MFC cu aplicații.

Dacă aplicația dvs. trebuie să schimbe pointeri către obiecte ale claselor MFC sau derivate ale acestora cu un DLL, trebuie să utilizeze extensia DLL descrisă în secțiunea următoare.

Arhitectura DLL-urilor obișnuite este concepută pentru a fi utilizată de alte medii de programare, cum ar fi Visual Basicși PowerBuilder.

Când creați un DLL MFC obișnuit folosind AppWizard, un proiect nou de tip MFC AppWizard (dll). În prima casetă de dialog a aplicației Expert, trebuie să selectați unul dintre modurile pentru bibliotecile dinamice obișnuite: „DLL obișnuit cu MFC legat statistic” sau „DLL obișnuit folosind DLL MFC partajat”. Primul oferă statică, iar al doilea - conexiune dinamică biblioteci MFC. Mai târziu, puteți schimba modul de conexiune MFC în DLL utilizând caseta combinată din fila General din caseta de dialog Setări proiect.

Gestionarea informațiilor despre starea MFC

Fiecare modul de proces MFC conține informații despre starea sa. Astfel, informațiile de stare ale unui DLL sunt diferite de informațiile de stare ale aplicației care a apelat-o. Prin urmare, orice funcții exportate din bibliotecă care sunt accesate direct din aplicații trebuie să spună MFC ce informații de stare să folosească. Într-o DLL MFC obișnuită care utilizează biblioteci dinamice MFC, înainte de a apela orice rutină MFC, trebuie să plasați următoarea linie la începutul funcției exportate:

AFX_MANAGE_STATE(AfxGetStaticModuleState()) ;

Această instrucțiune specifică utilizarea informațiilor de stare adecvate în timpul execuției funcției care apelează această subrutină.

Extensii MFC dinamice

MFC vă permite să creați DLL-uri care sunt percepute de aplicații nu ca un set de funcții separate, ci ca extensii ale MFC. Cu acest tip de DLL, puteți crea clase noi care derivă din clasele MFC și le puteți utiliza în aplicațiile dvs.

Pentru a permite ca pointerii către obiecte MFC să fie schimbate liber între o aplicație și un DLL, trebuie să creați o extensie MFC dinamică. DLL-urile de acest tip se conectează la bibliotecile dinamice MFC în același mod ca orice aplicație care utilizează extensia dinamică MFC.

Pentru a crea o nouă extensie MFC dinamică, cel mai simplu mod este să utilizați aplicația Expert pentru a atribui tipul de proiect MFC AppWizard (dll) iar la pasul 1 activați modul „MFC Extension DLL”. Ca rezultat, noului proiect i se vor atribui toate atributele necesare extensiei dinamice MFC. În plus, va fi creată o funcție DllMain pentru un DLL, care efectuează o serie de operațiuni specifice pentru a inițializa extensia DLL. Vă rugăm să rețineți că bibliotecile dinamice de acest tip nu contin si nu trebuie sa contina obiecte derivate din CWinApp.

Inițializarea extensiilor dinamice

Pentru a se potrivi în structura MFC, extensiile MFC dinamice necesită suplimentar configurare inițială. Operațiile corespunzătoare sunt efectuate de funcție DllMain. Să ne uităm la un exemplu de această funcție creată de expertul AppWizard.

Static AFX_EXTENSION_MODULE MyExtDLL = ( NULL, NULL ) ; extern "C" int APIENTRY DllMain(HINSTANCE hinstance, DWORD dwReason, LPVOID IpReserved) ( if (dwReason == DLL_PROCESS_ATTACH) ( TRACED("MYEXT.DLL Initializing!\n") ; // Extension DLL one-time Extension initialization AfLLMMInit , hinstance) ; // Inserați acest DLL în lanțul de resurse new CDynLinkLibrary(MyExtDLL) else if (dwReason == DLL_PROCESS_DETACH) ( TRACED("MYEXT.DLL Terminating!\n") ; ) return 1;

Cea mai importantă parte a acestei funcții este apelul AfxInitExtensionModule. Aceasta este inițializarea unei biblioteci dinamice, permițându-i să funcționeze corect ca parte a structurii MFC. Argumentele acestei funcții sunt descriptorul de bibliotecă DLL transmis către DllMain și structura AFX_EXTENSION_MODULE, care conține informații despre biblioteca dinamică conectată la MFC.

Nu este nevoie să inițializați structura AFX_EXTENSION_MODULE în mod explicit. Cu toate acestea, trebuie declarat. Constructorul se va ocupa de inițializare CDynLinkLibrary. Trebuie să creați o clasă în DLL CDynLinkLibrary. Constructorul său nu numai că va inițializa structura AFX_EXTENSION_MODULE, dar va adăuga și o nouă bibliotecă la lista de DLL-uri cu care poate lucra MFC.

Se încarcă extensii MFC dinamice

Începând cu versiunea 4.0, MFC vă permite să încărcați și să descărcați dinamic DLL-uri, inclusiv extensii. Pentru a efectua corect aceste operațiuni pe DLL-ul creat în funcția sa DllMainîn momentul deconectării de la proces, trebuie să adăugați un apel AfxTermExtensionModule. Ultima funcție i se trece structura AFX_EXTENSION_MODULE deja folosită mai sus ca parametru. Pentru a face acest lucru în text DllMain trebuie să adăugați următoarele rânduri.

If(dwReason == DLL_PROCESS_DETACH) ( AfxTermExtensionModule(MyExtDLL); )

În plus, trebuie amintit că bibliotecă nouă DLL-ul este o extensie dinamică și trebuie să fie încărcat și descărcat dinamic folosind funcții AfxLoadLibraryȘi AfxFreeLibrary,dar nu LoadLibraryȘi FreeLibrary.

Exportarea funcțiilor din extensii dinamice

Să ne uităm acum la modul în care funcțiile și clasele dintr-o extensie dinamică sunt exportate într-o aplicație. Deși puteți adăuga manual toate numele extinse în fișierul DEF, este mai bine să utilizați modificatori pentru declarațiile de clase și funcții exportate, cum ar fi AFX_EXT_CLASS și AFX_EXT_API, de exemplu:

Clasa AFX_EXT_CLASS CMyClass: public CObject (// Declarația dvs. de clasă ) void AFX_EXT_API MyFunc() ;