Aan de slag met testen, foutopsporing en afhandeling van uitzonderingen

7 minuten

Elke softwareontwikkelaar moet een bepaald niveau van testen en foutopsporing voltooien wanneer ze hun code ontwikkelen, en het verwerken van uitzonderingen is vaak vereist. Maar hoe zijn deze drie taken gerelateerd en wanneer moeten ze worden geïmplementeerd?

Afhandeling van tests, foutopsporing en uitzonderingen

Code-foutopsporing is duidelijk gerelateerd aan zowel het ontwikkelen als testen van code. U brengt immers correcties aan in uw codelogica tijdens het ontwikkelen van uw toepassing en u voert uw code ook periodiek uit om te controleren of uw codesyntaxis en logica juist zijn. Maar is het bijwerken van codelogica tijdens het ontwikkelingsproces eigenlijk wat wordt bedoeld door foutopsporing? En betekent het verifiëren dat uw code bouwt en draait echt wat wordt bedoeld met testen? Nee, niet echt.

Hoe verhoudt de afhandeling van uitzonderingen zich tot het ontwikkelen en testen van code? Wat betekent 'uitzonderingsafhandeling' in feite en wordt verwacht dat een ontwikkelaar dit doet? In C#-ontwikkeling worden de fouten die optreden tijdens de runtime van de toepassing (versus buildfouten die optreden tijdens het buildproces) aangeduid als uitzonderingen en 'uitzonderingsafhandeling' is het proces dat een ontwikkelaar gebruikt om deze runtime-uitzonderingen in hun code te beheren.

U vraagt zich misschien af hoe de afhandeling van uitzonderingen zich verhoudt tot het ontwikkelen en testen van code. Wat betekent 'uitzonderingsafhandeling' in feite en wordt verwacht dat een ontwikkelaar dit doet? In C#-ontwikkeling worden de fouten die optreden terwijl de toepassing wordt uitgevoerd, aangeduid als uitzonderingen. De term 'afhandeling van uitzonderingen' verwijst naar het proces dat een ontwikkelaar gebruikt om deze runtime-uitzonderingen in hun code te beheren. Fouten die optreden tijdens het buildproces worden fouten genoemd en maken geen deel uit van het proces voor het afhandelen van uitzonderingen.

In de volgende secties wordt de rol van de ontwikkelaar beschreven bij het testen, opsporen van fouten en het verwerken van uitzonderingen.

Verantwoordelijkheden voor softwaretests en ontwikkelaars

Het softwareontwikkelingsproces kan veel testen omvatten. Softwaretests hebben zelfs een eigen gespecialiseerde discipline en softwaretesters spelen een belangrijke rol bij de ontwikkeling van grote toepassingen. Er zijn zelfs benaderingen voor het softwareontwikkelingsproces die zijn gebaseerd op testen, zoals testgestuurde ontwikkeling.

Softwaretestcategorieën kunnen worden ingedeeld onder de soorten testen, de benaderingen voor testen of een combinatie van beide. Een manier om de typen tests te categoriseren, is het splitsen van tests in functionele en niet-functionele tests. De functionele en niet-functionele categorieën omvatten elk subcategorieën van tests. Functionele en niet-functionele tests kunnen bijvoorbeeld worden onderverdeeld in de volgende subcategorieën:

Functioneel testen - Eenheidstests - Integratietests - Systeemtests - Acceptatietests
Niet-functionele tests - Beveiligingstests - Prestatietests - Bruikbaarheidstests - Compatibiliteitstests

Hoewel de meeste ontwikkelaars zich waarschijnlijk niet als testers beschouwen, wordt een bepaald testniveau verwacht voordat een ontwikkelaar zijn werk aflevert. Wanneer ontwikkelaars een formele rol krijgen toegewezen in het testproces, is het vaak op het niveau van eenheidstests.

Opmerking

Omdat softwaretests zo'n groot onderwerp zijn en omdat het vaak wordt uitgevoerd door een afzonderlijke taakrol, worden formele benaderingen voor softwaretests niet besproken in deze module.

Code-foutopsporing en verantwoordelijkheden voor ontwikkelaars

Codeopsporing is een proces dat ontwikkelaars gebruiken om een probleem te isoleren en een of meer manieren te identificeren om dit probleem op te lossen. Het probleem kan betrekking hebben op codelogica of een uitzondering. In beide gevallen werkt u aan het opsporen van fouten in uw code wanneer deze niet werkt zoals u dat wilt. Over het algemeen is de term foutopsporing gereserveerd voor runtimeproblemen die niet eenvoudig te isoleren zijn. Daarom wordt het oplossen van syntaxisproblemen, zoals een ontbrekende ';', aan het einde van een code-instructie, normaal gesproken niet beschouwd als foutopsporing.

Bekijk de volgende voorbeeldcode:

string[] students = new string[] {"Sophia", "Nicolas", "Zahirah", "Jeong"};

int studentCount = students.Length;

Console.WriteLine("The final name is: " + students[studentCount]);

Het codevoorbeeld is bedoeld om het volgende te bereiken:

Declareer een tekenreeksmatrix met de naam students. De students array bevat de namen van studenten.
Declareer een geheel getal met de naam studentCount. De code gebruikt de Length methode van de matrix om een waarde toe te wijzen aan studentCount.
Druk de naam van de laatste leerling/student af op de console. De code gebruikt studentCount voor toegang tot de uiteindelijke naam in de students matrix en gebruikt de Console.WriteLine() methode om de gegevens af te drukken naar de console.

Op het eerste gezicht lijkt alles prima. Met deze code wordt echter een uitzondering gegenereerd bij het weergeven van de naam van de student op de console. De ontwikkelaar is vergeten dat matrices op nul zijn gebaseerd. De uiteindelijke naam in de matrix moet worden geopend met behulp van students[studentCount - 1].

Code-foutopsporing is absoluut een verantwoordelijkheid voor ontwikkelaars. In dit codevoorbeeld hebt u het probleem mogelijk meteen herkend. In complexere coderingsscenario's is het vinden van een probleem echter niet altijd eenvoudig. Geen zorgen, er zijn hulpprogramma's en benaderingen die u kunt gebruiken om problemen op te sporen die moeilijk te vinden zijn.

Afhandeling van uitzonderingen en verantwoordelijkheden voor ontwikkelaars

Zoals u eerder hebt gelezen, worden fouten die optreden tijdens de runtime van de toepassing aangeduid als uitzonderingen. Als een toepassing een uitzondering genereert en die uitzondering niet in code wordt beheerd, kan dit ertoe leiden dat de toepassing wordt afgesloten.

Het afhandelen van uitzonderingen is zeker een verantwoordelijkheid van de ontwikkelaar. C# biedt een manier om de code te 'tryen' waarvan u weet dat deze een uitzondering kan opleveren, en een manier om eventuele uitzonderingen te 'vangen'.

Samenvatting

Hier volgen enkele belangrijke dingen die u in deze les moet onthouden:

Testen, foutopsporing en afhandeling van uitzonderingen zijn allemaal belangrijke taken voor softwareontwikkelaars.
Testen kunnen worden gecategoriseerd in functionele en niet-functionele tests en ontwikkelaars zullen naar verwachting een bepaald niveau van testen uitvoeren.
Codefoutopsporing is het proces van het isoleren van problemen en het identificeren van manieren om deze op te lossen, en het is een verantwoordelijkheid voor ontwikkelaars.
Uitzonderingsafhandeling is het proces van het beheren van fouten die optreden tijdens runtime en ontwikkelaars zijn verantwoordelijk voor het afhandelen van uitzonderingen met behulp van 'try' en 'catch'-instructies in hun code.

Feedback

Is deze pagina nuttig?

Aan de slag met testen, foutopsporing en afhandeling van uitzonderingen

Uw kennis controleren

Feedback