C# prova cattura

Un'eccezione è uno stato o un evento che si è verificato al momento dell'esecuzione, che non è previsto durante la scrittura del codice sorgente. Per superare questa situazione, è necessario un codice speciale insieme all'oggetto eccezione per rettificarlo. Questo codice contiene quattro blocchi, di cui due di essi sono gli elementi principali che devono essere utilizzati per l'eccezione da gestire a Try e catturare i blocchi. Questi quattro blocchi sono spiegati di seguito.

• Prova: questo definisce un blocco di prova; Usiamo l'istruzione che può causare qualsiasi errore all'interno di questo blocco di prova.
• Catch: questo blocco viene utilizzato per catturare l'eccezione generata dal blocco di prova. L'oggetto di eccezione genera l'errore all'interno di questo blocco.
• Infine: qualsiasi codice che desideri generare in ogni caso è scritto all'interno di questo blocco.
• Lancio: questo blocco viene utilizzato per lanciare l'eccezione manualmente dal blocco di prova al blocco catch.

Esempio 1

Per implementare il concetto di Try-Catch, useremo prima un semplice programma in C Sharp. Innanzitutto, dichiarare una serie di tipi di dati interi. Durante la dichiarazione dell'array, non dobbiamo dichiarare le dimensioni dell'array. Ma, quando vengono assegnati i valori, l'indice viene fisso automaticamente. Quindi, in questo caso, verrà creata l'array di indice 4.

Int [] arr = 1, 2, 3, 4, 5;

Per visualizzare tutti gli elementi di un array, useremo un loop. La funzione dell'array, arr.La lunghezza () viene utilizzata per trovare la lunghezza totale dell'array fino alla quale il ciclo iterirà. Questa funzione viene chiamata tramite l'oggetto array. L'istruzione console svolgerà il suo ruolo nel visualizzare gli elementi dell'array. Ma useremo l'indice dell'array che va oltre la sua dimensione effettiva. Ad esempio, la dimensione dell'array è 4, ma useremo l'indice 7 per visualizzare il suo valore.

Console.WriteLine (arr [7]);

Ciò causerà un errore; Verrà lanciata un'eccezione quando viene eseguita questa riga.

Per compilare il codice precedente, abbiamo utilizzato il compilatore MCS richiesto nel terminale Linux, mentre Mono viene utilizzato per eseguire il codice eseguibile con il .Exe Extension.

File $ MCS.cs
File $ mono.exe

Il valore risultante sarà gli elementi presenti in un array visualizzati tramite il ciclo "per". Ma che dire dell'ultima riga utilizzata per visualizzare l'elemento al 7 ° indice dell'array? L'indice è fuori dall'intervallo dato, quindi si verificherà un'eccezione.

Per superare questo errore o per evitare l'eccezione, utilizziamo il concetto di provare e catturare. Questi due sono gli strumenti che utilizziamo all'interno del codice che aiutano nell'esecuzione regolare del codice senza evidenziare l'errore che fa terminare il programma.

Il fenomeno Try-Catch funziona in modo che l'istruzione o il codice che pensi possano causare una generazione di errori sia scritto all'interno del corpo prova. Ad esempio, la frase utilizzata per visualizzare il valore del 7 ° indice, scritto nel codice precedente, verrà utilizzata all'interno del corpo prova.

Ora applicheremo questo approccio al codice precedente. Tutti gli articoli sono visualizzati in modo simile dal ciclo rimanendo all'interno dell'intervallo dell'array. Quando si tratta della settima elemento indice, scrivi questa istruzione all'interno del blocco di prova.

Tentativo
Console.WriteLine (arr [7]);

Dopo aver dichiarato il corpo di prova, useremo il blocco di cattura. Questo blocco è la parte principale per evitare l'eccezione. Gestisce l'errore visualizzando il messaggio di errore e, allo stesso tempo, eseguendo correttamente il programma. Il messaggio visualizzato è la proprietà dell'oggetto che appartiene all'errore del tipo di indiceUtofRangeException.

Presa
Console.WriteLine ("Messaggio", E.Messaggio);

Questo messaggio funzionerà attraverso l'oggetto; Un messaggio è ciò che abbiamo usato, mentre l'oggetto visualizza l'altro.

Puoi vedere il valore risultante. Il messaggio di errore viene visualizzato tramite i blocchi try-catch.

Esempio n. 2

Non è obbligatorio usare sempre un singolo tentativo e un singolo blocco di cattura. Possiamo usare più di un blocco di cattura per un singolo blocco di prova. Nel codice C. L'utente non è a conoscenza del tipo di eccezione. Ecco perché utilizziamo diversi blocchi di cattura per gestire qualsiasi tipo di errore che possiamo incontrare.

Usando più catture, esistono un blocco finale. Questa parte del codice viene eseguita indipendentemente dal fatto che si verifichi l'errore.

Di seguito è riportata la semplice sintassi di più catture:

Tentativo

// qualsiasi istruzione
Catch (OBJ)

// codice gestore
Catch (OBJ)

// codice gestore
Finalmente

// codice predefinito

Nell'esempio dato, visualizzeremo i valori all'interno dell'array nel blocco finalmente. Considera il codice sorgente in cui viene dichiarato un array di 4 elementi. All'interno del corpo di prova, abbiamo usato per loop per recuperare ogni elemento di un array e applicare la condizione data.

Console.WriteLine (arr [i] / arr i +1]);

All'interno del ciclo, ogni elemento viene recuperato e diviso per il prossimo numero dell'array. Dopo il corpo di prova, useremo una sequenza di blocchi di cattura per menzionare le eccezioni di diversi tipi che possono essere verificati in base alla situazione.

Catch (IndexoTofRangeException E)

Il primo blocco è per l'eccezione fuori portata insieme all'oggetto. Verrà visualizzato un messaggio con l'oggetto.

Allo stesso modo, il secondo blocco catch sarà:

Catch (Dividebyzerexception e)

Questa eccezione si verificherà se qualsiasi numero è diviso per zero.

Il terzo e l'ultimo tipo di cattura è per i parametri scritti nell'argomento in eccesso di valore anziché l'intervallo nelle variabili dichiarate.

Catch (argomentautooutofrangeexception e)

Definendoli, saprai che il problema verrà eseguito e visualizzerà il valore.

Muovendosi verso il blocco finalmente. Verrà eseguito se si verifica o meno un'eccezione. E un ciclo per al suo interno visualizzerà i valori di un array.

Abbiamo usato la condizione di divisione per dividere il numero con il numero presente accanto ad esso. Quindi, se vediamo i valori nella seconda posizione e in 1 indice, c'è "0", quindi qualsiasi cosa divisa con 0 provoca un'eccezione.

Innanzitutto, l'errore viene definito e quindi il blocco finale visualizzerà tutti i valori.

Conclusione

Un processo di gestione delle eccezioni si occupa di identificare gli errori e quindi risolverli. Questo viene fatto utilizzando i blocchi try-catch all'interno del codice sorgente. Il codice che dubiti che possa causare un'eccezione è scritto all'interno del tentativo e il blocco catch rimuoverà questa eccezione. Per un singolo tentativo, vengono utilizzate una singola cattura e più catture. Puoi usare qualsiasi oggetto di eccezione che puoi pensare possa essere utile per la possibile eccezione. Abbiamo implementato esempi in seguito al singolo cattura e agli approcci di cattura multipli.