Introduzione ai test, al debug e alla gestione delle eccezioni
- 7 minuti
Ogni sviluppatore software deve completare un certo livello di test e debug quando sviluppa il codice e spesso è necessaria la gestione delle eccezioni. Ma come sono correlate queste tre attività e quando devono essere implementate?
Test, debug e gestione delle eccezioni
Il debug del codice è chiaramente correlato allo sviluppo e al test del codice. Dopo tutto, si apportano correzioni alla logica del codice durante lo sviluppo dell'applicazione e si esegue periodicamente il codice per verificare che la sintassi del codice e la logica siano corrette. L'aggiornamento della logica del codice durante il processo di sviluppo è in realtà ciò che significa eseguire il debug? E sta verificando che il codice venga compilato ed eseguito realmente cosa significa testare? No, non proprio.
In che modo la gestione delle eccezioni è correlata allo sviluppo e al test del codice? In effetti, cosa significa la "gestione delle eccezioni" e si prevede che lo sviluppatore lo faccia? Nello sviluppo C# gli errori che si verificano durante il runtime dell'applicazione (rispetto agli errori di compilazione che si verificano durante il processo di compilazione) vengono definiti eccezioni e la "gestione delle eccezioni" è il processo usato da uno sviluppatore per gestire tali eccezioni di runtime all'interno del codice.
Ci si potrebbe chiedere in che modo la gestione delle eccezioni si riferisce allo sviluppo e al test del codice. In effetti, cosa significa la "gestione delle eccezioni" e si prevede che lo sviluppatore lo faccia? Nello sviluppo C# gli errori che si verificano durante l'esecuzione dell'applicazione vengono definiti eccezioni. Il termine "gestione delle eccezioni" si riferisce al processo usato da uno sviluppatore per gestire tali eccezioni di runtime all'interno del codice. Gli errori che si verificano durante il processo di compilazione vengono definiti errori e non fanno parte del processo di gestione delle eccezioni.
Le sezioni seguenti descrivono il ruolo dello sviluppatore nel test, nel debug e nella gestione delle eccezioni.
Responsabilità dei test software e degli sviluppatori
Il processo di sviluppo software può comportare un sacco di test. Infatti, i test software hanno una propria disciplina specializzata e i tester software svolgono un ruolo importante nello sviluppo di applicazioni di grandi dimensioni. Esistono anche approcci al processo di sviluppo software basato su test, ad esempio lo sviluppo basato su test.
Le categorie di test software possono essere organizzate in base ai tipi di test, agli approcci ai test o a una combinazione di entrambi. Un modo per classificare i tipi di test consiste nel suddividere i test in test funzionali e non funzionali . Le categorie funzionali e non funzionali includono ognuna sottocategorie di test. Ad esempio, i test funzionali e non funzionali possono essere suddivisi nelle sottocategorie seguenti:
- Test funzionali - Testing unità - Test di integrazione - Test di sistema - Test di accettazione
- Test non funzionali - Test di sicurezza - Test delle prestazioni - Test di usabilità - Test di compatibilità
Anche se la maggior parte degli sviluppatori probabilmente non considerarsi tester, è previsto un certo livello di test prima che uno sviluppatore disegni il proprio lavoro. Quando agli sviluppatori viene assegnato un ruolo formale nel processo di test, è spesso a livello di unit test.
Annotazioni
Poiché il test software è un argomento di questo tipo e poiché viene spesso eseguito da un ruolo di lavoro separato, gli approcci formali ai test software non verranno illustrati in questo modulo.
Responsabilità del debug del codice e degli sviluppatori
Il debug del codice è un processo che gli sviluppatori usano per isolare un problema e identificare uno o più modi per risolverlo. Il problema potrebbe essere correlato alla logica del codice o a un'eccezione. In entrambi i casi, è possibile eseguire il debug del codice quando non funziona nel modo desiderato. In generale, il termine debug è riservato ai problemi di runtime che non sono facili da isolare. Pertanto, la correzione di problemi di sintassi, ad esempio ";" mancanti alla fine di un'istruzione di codice, non viene in genere considerata debug.
Si consideri il codice di esempio seguente:
string[] students = new string[] {"Sophia", "Nicolas", "Zahirah", "Jeong"};
int studentCount = students.Length;
Console.WriteLine("The final name is: " + students[studentCount]);
L'esempio di codice è progettato per eseguire le operazioni seguenti:
- Dichiarare una matrice di stringhe denominata
students. Lastudentsmatrice contiene i nomi degli studenti. - Dichiarare un numero intero denominato
studentCount. Il codice usa ilLengthmetodo della matrice per assegnare un valore astudentCount. - Stampare il nome dello studente finale nella console. Il codice usa
studentCountper accedere al nome finale nellastudentsmatrice e usa ilConsole.WriteLine()metodo per stampare le informazioni nella console.
A prima vista, tutto sembra bene. Tuttavia, questo codice genera un'eccezione quando si tenta di stampare il nome dello studente nella console. Lo sviluppatore ha dimenticato che le matrici sono in base zero. È necessario accedere al nome finale nella matrice usando students[studentCount - 1].
Il debug del codice è sicuramente una responsabilità per gli sviluppatori. In questo esempio di codice è possibile che il problema sia stato riconosciuto immediatamente. Tuttavia, in scenari di codifica più complessi, la ricerca di un problema non è sempre facile. Non preoccuparti, ci sono strumenti e approcci che è possibile usare per tenere traccia dei problemi difficili da trovare.
Gestione delle eccezioni e responsabilità dello sviluppatore
Come si legge in precedenza, gli errori che si verificano durante il runtime dell'applicazione vengono definiti eccezioni. Se un'applicazione genera un'eccezione e tale eccezione non è gestita nel codice, può comportare l'arresto dell'applicazione.
La gestione delle eccezioni è sicuramente responsabilità dello sviluppatore. C# consente di "provare" il codice che si sa potrebbe generare un'eccezione e un modo per "intercettare" tutte le eccezioni che si verificano.
Riepilogo
Ecco i concetti più importanti di questa unità da ricordare:
- I test, il debug e la gestione delle eccezioni sono tutte attività importanti per gli sviluppatori di software.
- I test possono essere classificati in test funzionali e non funzionali e gli sviluppatori devono eseguire un certo livello di test.
- Il debug del codice è il processo di isolamento dei problemi e l'identificazione di modi per risolverli ed è responsabilità dello sviluppatore.
- La gestione delle eccezioni è il processo di gestione degli errori che si verificano durante il runtime e gli sviluppatori sono responsabili della gestione delle eccezioni tramite istruzioni "try" e "catch" nel codice.