Fouten opsporen in DLL's in Visual Studio (C#, C++, Visual Basic, F#)

2025-06-12

Een DLL (dynamic-link library) is een bibliotheek die code en gegevens bevat die door meer dan één app kunnen worden gebruikt. U kunt Visual Studio gebruiken om DLL's te maken, te bouwen, te configureren en fouten op te sporen.

Een DLL maken

Met de volgende Visual Studio-projectsjablonen kunt u DLL's maken:

Bibliotheek voor klassen (.NET, .NET Framework en andere toepassingsplatforms)
Windows Forms Control Library (.NET en .NET Framework)
Dynamic-Link Bibliotheek (DLL) (C++)

Foutopsporing in een Windows Forms-besturingselementbibliotheek is vergelijkbaar met het opsporen van fouten in een klassebibliotheek. Zie Besturingselementen voor Windows Forms voor meer informatie.

Meestal roept u een DLL aan vanuit een ander project. Wanneer u fouten opssport in het aanroepende project, kunt u, afhankelijk van de DLL-configuratie, de DLL-code instappen en fouten opsporen.

Configuratie voor dll-foutopsporing

Wanneer u een Visual Studio-projectsjabloon gebruikt om een app te maken, worden in Visual Studio automatisch de vereiste instellingen gemaakt voor configuraties voor foutopsporing en release-build. U kunt deze instellingen indien nodig wijzigen. Zie de volgende artikelen voor meer informatie:

C++ DebuggableAttribute instellen

Opdat het foutopsporingsprogramma zich aan een C++-DLL kan koppelen, moet de C++-code DebuggableAttribute genereren.

Om in te stellen DebuggableAttribute:

Selecteer het C++ DLL-project in Solution Explorer en selecteer het pictogram Eigenschappen of klik met de rechtermuisknop op het project en selecteer Eigenschappen.
Selecteer in het deelvenster Eigenschappen onderLinker-foutopsporing>Ja (/ASSEMBLYDEBUG) voor Debuggable Assembly.

Zie /ASSEMBLYDEBUG voor meer informatie.

C/C++ DLL-bestandslocaties instellen

Als u fouten wilt opsporen in een externe DLL, moet een aanroepend project het DLL-bestand, het .pdb-bestand en alle andere bestanden kunnen vinden die het DLL-bestand nodig heeft. U kunt een aangepaste build-taak maken om deze bestanden te kopiëren naar uw <projectmap>\Debug-uitvoermap, of u kunt de bestanden daar handmatig kopiëren.

Voor C/C++-projecten kunt u header- en LIB-bestandslocaties instellen op de projecteigenschapspagina's in plaats van ze naar de uitvoermap te kopiëren.

C/C++-header- en LIB-bestandslocaties instellen:

Selecteer het DLL-project C/C++ in Solution Explorer en selecteer het pictogram Eigenschappen of klik met de rechtermuisknop op het project en selecteer Eigenschappen.
Selecteer boven aan het deelvenster Eigenschappen onder Configuratiealle configuraties.
Geef onder C/C++>Algemeen>Aanvullende Include Dossiers de map op die headerbestanden bevat.
Geef onder Linker>General>Additional Libraries Directory's de map met LIB-bestanden op.
Geef onder Linker>Invoer>Aanvullende afhankelijkheden het volledige pad en de bestandsnaam voor de LIB-bestanden op.
Kies OK.

Zie de naslaginformatie over de eigenschappenpagina van Windows C++ voor meer informatie over C++-projectinstellingen.

Een foutopsporingsversie bouwen

Zorg ervoor dat u een foutopsporingsversie van het DLL-bestand maakt voordat u begint met foutopsporing. Als u fouten in een DLL wilt opsporen, moet een aanroepende app het .pdb-bestand kunnen vinden en alle andere bestanden die het DLL-bestand vereist. Zie voor meer informatie Debug- en releaseconfiguraties instellen.

U kunt een aangepaste build-taak maken om de DLL-bestanden te kopiëren naar de <aanroepende projectmap>\Uitvoermap voor foutopsporing , of u kunt de bestanden daar handmatig kopiëren.

Zorg ervoor dat u het DLL-bestand op de juiste locatie aanroept. Dit lijkt misschien duidelijk, maar als een aanroepende app een andere kopie van het DLL-bestand vindt en laadt, raakt het foutopsporingsprogramma nooit de onderbrekingspunten die u hebt ingesteld.

Fouten opsporen in een DLL

U kunt een DLL niet rechtstreeks uitvoeren. Het moet worden aangeroepen door een app, meestal een .exe-bestand .

Als u fouten in een DLL wilt opsporen, kunt u fouten opsporen vanuit de aanroepende app of fouten opsporen in het DLL-project door de aanroepende app op te geven. U kunt ook het foutopsporingsprogramma Direct gebruiken om DLL-functies of -methoden tijdens het ontwerp te evalueren, zonder een aanroepende app te gebruiken.

Foutopsporing starten vanuit de aanroepende app

De app die een DLL aanroept, kan het volgende zijn:

Een app uit een Visual Studio-project in dezelfde of een andere oplossing dan het DLL-bestand.
Een bestaande app die al is geïmplementeerd en wordt uitgevoerd op een test- of productiecomputer.
Bevindt zich op het web en wordt geopend via een URL.
Een web-app met een webpagina die het DLL-bestand insluit.

Voordat u begint met het opsporen van fouten in de aanroepende app, stelt u een onderbrekingspunt in het DLL-bestand in. Zie Aan de slag met onderbrekingspunten. Wanneer het DLL-onderbrekingspunt wordt bereikt, kunt u de code doorlopen en de actie op elke regel observeren. Zie Navigate-code in het foutopsporingsprogramma voor meer informatie.

Als u fouten wilt opsporen in een DLL vanuit een aanroepende app, kunt u het volgende doen:

Open het project voor de aanroepende app en start de foutopsporing door Foutopsporing>starten te selecteren of op F5 te drukken.

of
Koppel deze aan een app die al is geïmplementeerd en wordt uitgevoerd op een test- of productiecomputer. Gebruik deze methode voor DLL's op websites of in web-apps. Zie Procedure: Koppelen aan een actief proces voor meer informatie.

Tijdens foutopsporing kunt u het venster Modules gebruiken om de DLL's te controleren en .exe bestanden die de app laadt. Tijdens het foutopsporen selecteert u Foutopsporing>> om het venster Modules te openen. Zie Het venster Modules gebruiken voor meer informatie.

Het venster Direct gebruiken

U kunt het venster Direct gebruiken om DLL-functies of -methoden te evalueren tijdens het ontwerp. Het Immediate-venster speelt de rol van een aanroepende app.

Opmerking

U kunt het venster Direct tijdens het ontwerpen gebruiken met de meeste projecttypen. Het wordt niet ondersteund voor SQL, webprojecten of scripts.

Als u bijvoorbeeld een methode wilt testen met de naam Test in klasse Class1:

Open het DLL-project, en open het venster Immediate door Debug>Windows>Immediate te selecteren of door op Ctrl+Alt+I te drukken.
Instantieer een object van het type Class1 door de volgende C#-code in het venster Direct te typen en op Enter te drukken. Deze beheerde code werkt voor C# en Visual Basic, met de juiste syntaxiswijzigingen:
```
Class1 obj = new Class1();
```
In C# moeten alle namen volledig zijn gekwalificeerd. Methoden of variabelen moeten zich in het huidige bereik en de huidige context bevinden wanneer de taalservice de expressie probeert te evalueren.
Ervan uitgaande dat er Test één int parameter nodig is, evalueer Test met behulp van het venster Onmiddellijk:
```
?obj.Test(10);
```
Het resultaat wordt afgedrukt in het venster Direct .
U kunt fouten blijven opsporen Test door er een onderbrekingspunt in te plaatsen en vervolgens de functie opnieuw te evalueren.

Het onderbrekingspunt wordt bereikt, en u kunt doorstappen Test. Nadat de uitvoering Test is beëindigd, keert de debugger terug naar de ontwerpmodus.

Foutopsporing in gemengde modus

U kunt een aanroepende app schrijven voor een DLL in beheerde of systeemeigen code. Als uw systeemeigen app een beheerde DLL aanroept en u beide wilt opsporen, kunt u zowel de beheerde als systeemeigen foutopsporingsprogramma's inschakelen in de projecteigenschappen. Het exacte proces is afhankelijk van of u foutopsporing wilt starten vanuit het DLL-project of het aanroepende app-project. Zie Procedure: Fouten opsporen in gemengde modus voor meer informatie.

U kunt ook fouten opsporen in een systeemeigen DLL vanuit een beheerd aanroepend project. Zie How to debug managed and native code (Fouten opsporen in beheerde en systeemeigen code) voor meer informatie.