Visual Basic 2012 Voorbeelden
   

visual basic 2012 broncode voorbeelden

Blijf op de hoogte van de recente aanpassingen op vbvoorbeelden!

Microsoft Visual Studio 2012Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

32.1. Debugging in Visual Studio

Print Email Deel op Twitter Deel op Facebook

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

Dit onderwerp veronderstelt Visual Studio 2008 Professional Edition, maar is grotendeels ook van toepassing op de Standard en Express Editions en op de vorige versies van Visual Studio (zoals 2003, 2005 en 2010).

Aan de hand van een overzicht van enkele debugmogelijkheden in de Visual Studio IDE (Integrated Development Environment) wordt hier de basis van het debuggen besproken.

32.1.1. Design, Debugging en Running Mode

Visual Studio kan zich in drie verschillende modi bevinden :

Tijdens het coderen bevindt de IDE zich in design modus.

Tijdens het uitvoeren van een applicatie, gestart met Visual Studio, bevindt de IDE zich in running modus.
Bemerk dat op dat moment in de titlebar tussen haakjes "Running" is weergegeven.

Indien een exception (runtime fout) zou optreden, bij een applicatie die wordt gestart vanuit Visual Studio, gaat de IDE over in debugging modus, ook wel een break modus genoemd.
Op dat moment staat op de titlebar tussen haakjes "Debugging" weergegeven.
Deze modus is ideaal om de oorzaak van fouten (logisch fouten of runtime fouten) op te sporen.
Extra toolvensters zijn aanwezig in deze modus, die je bijvoorbeeld het voorbije programmaverloop of de huidige inhoud van variabelen laten analyseren.
In break modus kan je ook de inhoud van dataholders (op dat moment tijdens uitvoering) inspecteren door de cursor boven de identifier van bijvoorbeeld een variabele te plaatsen, dit noemt men ook wel "DataTips".

Het is overigens zo dat per modus de zichtbare toolvensters en hun positie in de IDE kan configureren.

32.1.2. Uitvoering Onderbreken en Breakpoints

Door het kiezen voor de Break All optie in de Debug menu (of aan de hand van de pause knop op de corresponderende toolbar) kan je tijdens runtime ( running modus) overschakkelen op debugging modus.

Ook in de code zelf kan je een breakpoint plaatsen.  Breakpoints zijn plaatsen (instructieregels) in de code waar men tijdens uitvoering de IDE in break modus laat overgaan.  Het programma stopt nog voor de regel met de breakpoint wordt uitgevoerd.
Men kan ondermeer breakpoints plaatsen door :
- te klikken op de grijze zone links een instructieregel
- te rechterklikken op een bepaalde coderegel en te kiezen voor Run To Cursor
- een Stop instructie op te nemen in de code waar je naar debug modus wil overgaan

32.1.3. Door de Code Stappen en Call Stack Toolvenster

Eens in debug modus kan je stap voor stap het programma laten verderlopen.
In de Debug menu kan je kiezen voor Step Into, Step Over en Step Out :
- Step Into zal indien de huidige regel (in het geel weergegeven) een call naar een andere routine in ons programma bevat, ook door deze routine stappen.
- Step Over zal dergelijke aangeroepen routine meteen volledig uitvoeren, en pas na de return van deze routine het programma onderbreken.
- Step Out zal de huidige routine volledig uitvoeren, en pas de uitvoer opnieuw onderbreken op de plaats van de call naar deze huidige routine.

Het Call Stack toolvenster is een ideale tool om te zien hoe men in de huidige method (waar de break modus zicht op dit moment in bevindt) is terecht gekomen.  In dit overzicht is ook te zien welke argumentwaardes zijn doorgegeven bij de calls naar deze methods.

32.1.4. Breakpoints Toolvenster

Een overzicht van alle breakpoints kan je vinden in het Breakpoints toolvenster.  Je kan dit toolvenster zien als je in de Debug menu kiest voor Windows en Breakpoints.
Via dit toolvenster kan je eenvoudig naar een breakpoint in de code navigeren, breakpoints toevoegen of verwijderen, disablen of enablen.
Deze mogelijkheden vind je ook terug in de Debug menu of toolbar, of in de contextmenu die je krijgt bij het rechterklikken op een breakpoint in de code-editior.

Het plaatsen, verwijderen, aanpassen, enablen en disablen van breakpoints kan in alle modi, zowel Design, als Debugging, als Running modus.

32.1.5. Breakpoint Filters

De mogelijkheid bestaat filters toe te passen op breakpoints, om deze te beperken tot bepaalde machines, processen of threads.

Neem onderstaande code over en plaats een breakpoint op regel (1) :
Visual Basic 2012 Broncode - Codevoorbeeld 790
Class Example1
    Public Shared Sub Main()
        Dim thread1 As New System.Threading.Thread(AddressOf Test)
        thread1.Name = "thread1"
        '
        Dim thread2 As New System.Threading.Thread(AddressOf Test)
        thread2.Name = "thread2"
        '
        thread1.Start(1)
        thread2.Start(2)
        '
        Console.ReadLine()
    End Sub
    Public Shared Sub Test(ByVal ID As Integer)
        Console.WriteLine("Test " & ID)                                    ' (1)
    End Sub
End Class
Console Application Output
Test 1
Test 2
Voer je de code uit, dan merk je dat zowel voor Test met ID waarde één als voor Test met ID waarde twee wordt gebroken.  Voor beide threads wordt gebroken.

Rechterklik op het breakpoint en kies voor Filter ..., in het bekomen Breakpoint Filter dialog neem je nu de expressie ThreadName = "thread2" op.

Bemerk in de code-editor dat het witte kruis in de rode breakpointbal aangeeft dat dit geen onvoorwaardelijke breakpoint is.

Voer opnieuw de code uit en bemerk dan nu slechts voor Test met ID waarde twee (en dus enkel voor de tweede thread) wordt gebroken.

Enkel indien voldaan is aan de filter wordt het programma onderbroken.

32.1.6. Breakpoint Conditions

Hetzelfde resultaat kunnen we bekomen door een meer algemene breakpoint condition.

Verwijder de breakpoint, en plaats op dezelfde regels een nieuw breakpoint, rechterklik en kies voor Condition ..., daar vul de de conditie ID = 2 in.

Opnieuw wordt slechts gebroken voor Test met ID waarde twee.

32.1.7. Breakpoint Hit Count

Indien je op een bepaald punt in de code slechts wenst te breken indien dit punt een aantal keer wordt bereikt, kan je dit instellen via een Hit Count.

Verwijder opniew in bovenstaand voorbeeld het breakpoint, en plaats er een nieuwe.  Rechterklik en kies voor Hit Count ..., daar krijg je volgende opties :
- break always
- break when the hit count is equal to
- break when the hit count is a multiple of
- break when the hit count is greater than or equal to

Kies voor de tweede optie en voer twee in.  Waarschijnlijk zal nu bij de uitvoer opnieuw gebroken worden voor Test met ID waarde twee.
Dit is natuurlijk niet met absolute zekerheid te stellen gezien men niet weet welke thread eerst zal worden verwerkt.  Maar gezien we de tweede thread pas na de eerste starten, zal het dus waarschijnlijk voor Test met ID waarde 2 zijn.

32.1.8. Tracepoints of Breakpoints met When Hit Acties

Het is mogelijk een macro uit te voeren of een boodschap af te printen bij de uitvoer van een regel met een breakpoint.  Breakpoints met daaraan dergelijke actie gekoppeld noemt men ook wel een tracepoint.

Verwijder opniew in bovenstaand voorbeeld het breakpoint, en plaats er een nieuwe.  Rechterklik en kies voor When Hit ..., in de bekomen When Breakpoint Is Hit dialog, kies je voor Print a message en vul je volgende expressie in :
Function: $FUNCTION with ID {ID}, Thread: $TID $TNAME
Deze zal er voor zorgen dat de functienaam, de threadID en threadnaam zal worden afgeprint.  Dit aan de hand van enkele special keywords.  De inhoud van variabelen bekom je door in dergelijke expressie de identifier van die variabele met accolades te omsluiten (bijvoorbeeld {ID}).
De optie Continue execution zorgt ervoor dat niet gebroken wordt en enkel de actie wordt uitgevoerd.

Bemerk het ruiticoontje in de code-editior die een tracepoint aangeeft.

Voer de code uit en bekijk het Output toolvenster, volgende boodschappen verschijnen daar :
Function: Content.Example1.Test(Integer) with ID 1, Thread: 0x1628 thread1
Function: Content.Example1.Test(Integer) with ID 2, Thread: 0x26F4 thread2
Filters, Conditions, Hit Counts en When Hit acties kunnen ook gecombineerd worden.

32.1.9. Verplaatsen van een Breakpoint

Een breakpoint kan verplaatst worden door voor de optie Location te kiezen.  In de daar bekomen dialog zou men de nieuwe locatie van de breakpoint aan te geven.

Indien het om een eenvoudig breakpoint gaat, zal je deze waarschijnlijk niet verplaatsen, maar eerder verwijderen om een ander breakpoint te plaatsen op de nieuwe locatie.
Je zal misschien wel van deze mogelijkheid gebruik maken indien het te verplaatsen breakpoint Filters, Conditions, Hit Counts of When Hit acties bevat.

32.1.10. Debugging at Designtime - Immediate Window

Ook zonder het programma zelf te laten uitvoeren is het mogelijk bepaalde expressie te evalueren.  Men kan bijvoorbeeld aan de hand van het Immediate toolvenster een bepaald expressieresultaat laten afdrukken.

Neem volgende code over :
Visual Basic 2012 Broncode - Codevoorbeeld 791
Class Example2
    Public Shared Sub Main()
        Console.WriteLine(Method1(10))
    End Sub
    Public Shared Function Method1(ByVal value As Integer) As Integer
        Return value * 2
    End Function
End Class
Maak het Immediate toolvenster zichtbaar, kies in de Debug menu voor Windows en Immediate.  Voer in dat venster Debug.Print(Example2.Method1(10)) in en druk op Enter.  In het Immediate venster verschijnt op de volgende regel de waarde 20.

Ook in debug modus is het Immediate toolvenster bruikbaar.

Plaats een breakpoint op het Return statement, en voer het programma uit.  In het immediate venster plaats je Debug.Print(value) en druk je op Enter.
In het Immediate venster verschijnt opnieuw 20.

Functie Debug.Print(value) kan je ook vervangen door ?value.  ? is een alias voor Debug.Print

32.1.11. Command Window

Naast het Immediate Window bestaat er ook een Command Window.  Deze is bruikbaar om Visual Studio opdrachten, die al dan niet ook via de menu te benaderen zijn, uit te voeren.

In de View menu kies je voor Other Windows en Command Window.

Enkele voorbeelden :

- immed schakelt over naar Immediate toolvenster.
- Edit.Find test /regex zoekt in de editor naar de tekst test.  Reguliere expressies worden hier ondersteunt.

Naast deze opdrachten kan je dit toolvenster ook gebruiken om in break modus de inhoud van variabelen te inspecteren, bijvoorbeeld aan de hand van de opdracht ? value.

32.1.12. Start Opties voor het Debuggen

Indien je in een console applicatie (commandline applicatie) schakelopties gebruikt, zou het handig zijn om vanuit de Visual Studio IDE bij het testen van deze applicatie te kunnen bepalen met welke argumentwaardes deze applicatie wordt uitgevoerd.
Visual Basic 2012 Broncode - Codevoorbeeld 792
Class Example3
    Public Shared Sub Main()
        Dim arguments As String() = Environment.GetCommandLineArgs()
        '
        Dim value1 As Integer = arguments(1)
        Dim value2 As Integer = arguments(2)
        Dim operation As String = arguments(3)
        '
        Select Case operation
            Case "/operation:sum"
                Console.WriteLine(value1 & " + " & value2 & " = " & _
                                  value1 + value2)
            Case "/operation:multiply"
                Console.WriteLine(value1 & " * " & value2 & " = " & _
                                  value1 * value2)
            Case Else
                Console.WriteLine("Unknown operation.")
        End Select
        '
        Console.ReadLine()
    End Sub
End Class
Bovenstaande applicatie zou je in de commandprompt kunnen uittesten aan de hand van de opdrachten Example3.exe 4 5 /operation:sum en Example3.exe 4 5 /operation:multiply die respectievelijk 4 + 5 = 9 en 4 * 5 = 20 als output geven.

Dit kan ook vanuit de Visual Studio IDE zelf.  Bij de project properties vul je hiervoor op het tabblad Debug bij de optie Command line arguments 4 5 /operation:sum of 4 5 /operation:multiply in.

32.1.13. Variable Windows

Veel gebruikte toolvensters bij het debuggen zijn de Locals, Autos en Watch toolvensters.  Deze staan ons toe tijdens debugging modus de inhoud van variabelen te analyseren en zelfs aan te passen.

Het Locals venster toont ons de lokale variabelen, maar bijvoorbeeld ook het object zelf dat in invoering is (Me).

Het Autos venster toon de variabelen die op de huidige lijn in gebruik zijn of in de vorige drie lijnen in gebruik waren.  Dit kunnen ook variabelen zijn met een andere scope dan de lokale, bijvoorbeelden velden van een klasse.

Het Watch venster staat ons toe expressies in te voeren om het resultaat daarvan te analyseren.

Het Autos, Locals en Watch venster heeft steeds drie kolommen.  De Name kolom bevat de identifier van de dataholder of de te evalueren expressie.  De Value kolom bevat de inhoud van de dataholder of de waarde waar naartoe de expressie evalueert.  De Type kolom bevat het statisch type van deze dataholder of expressie.  Indien het dynamisch type van het statisch type verschilt, bevat de Value kolom ook het dynamisch type.

Neem onderstaande code over, zet op regel (1) en (2) twee breakpoints en voer de code uit :
Visual Basic 2012 Broncode - Codevoorbeeld 793
Class Counter
    Private _Value As Integer
    Public Sub New(ByVal value As Integer)
        _Value = value                                                    ' (1)
    End Sub
    Public ReadOnly Property Value() As Integer
        Get
            Value = _Value
        End Get
    End Property
    Public Sub Raise()
        _Value += 1
    End Sub
End Class
Class Example4
    Public Shared Sub Main()
        Dim counter1 As New Counter(5)
        Dim arrayList1 As New ArrayList
        arrayList1.Add(counter1)
        '
        Console.ReadLine()                                                 ' (2)
    End Sub
End Class
Bij het eerste breakpoint toon het Autos venster ons de variabelen _Value en value.  Het Locals venster toont ons de value en Me.

Stel dat we bij het tweede breakpoint geïntresseerd zijn in de Capacity van arrayList1, dan kunnen we deze niet bekijken in het Autos of Locals toolvenster.  Dezen tonen ons enkel de items van arrayList1.
In het Watch toolvenster kunnen we echter wel de expressie arrayList1.Capacity opnemen en laten evalueren.

Er bestaat ook een QuickWatch venster, met ongeveer dezelfde mogelijkheden als het het Watch venster, maar die als een aparte dialog wordt getoond.

Bemerk dat je in de Value kolom ook de inhoud kunt aanpassen.

32.1.14. Processes, Threads en Modules Windows

Toolvensters als Processes, Threads en Modules kunnen ons in break modus respectievelijk een overzicht geven van de huidige processen, threads en ingeladen modules (.exe en .dll bestanden).

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.