Salta dichiarazioni in C#

Nelle dichiarazioni di salto C# controllano il flusso di un programma. Le dichiarazioni di salto consentono agli utenti di trasferire il controllo da una parte all'altra all'interno di un codice. Sono utili in situazioni in cui si desidera saltare un po 'di codice o ripetere una sezione di codice più volte.

Questo articolo copre i diversi tipi di dichiarazioni di salto in C#, come funzionano e quando usarli.

Sommario

1: dichiarazioni di salto in C#

2: tipi di dichiarazioni di salto in C#

• • 1: Dichiarazione Goto
  • 2: Break Dichiarazione
  • 3: Continua la dichiarazione
  • 4: Dichiarazione di ritorno
  • 5: Dichiarazione di lancio

Conclusione

1: dichiarazioni di salto in C#

Le istruzioni di salto sono un costrutto di programmazione utilizzato per controllare il flusso di esecuzione all'interno di un blocco di codice. Consente al programma di saltare determinate sezioni di codice o ripeterle in base a determinate condizioni. Le dichiarazioni di salto possono essere utili in situazioni come la gestione degli errori o i costrutti di looping.

2: tipi di dichiarazioni di salto in C#

In C#, ci sono cinque tipi di dichiarazioni di salto:

• • GOTO Dichiarazione
  • Dichiarazione di pausa
  • Continua la dichiarazione
  • Dichiarazione di ritorno
  • Dichiarazione di lancio

Ognuna di queste affermazioni ha la sua funzionalità e l'uso unici. Ecco una descrizione dettagliata di ogni dichiarazione di salto in C#.

1: Dichiarazione Goto in C#

La dichiarazione GOTO in C# ti consente di passare a una dichiarazione etichettata nel tuo programma. Per usare vai a In C# è richiesta un'etichetta. L'etichetta è un'affermazione che hai segnato con un identificatore specifico e deve essere seguita da un colon.

IL sintassi per usare il vai a Dichiarazione in C# è la seguente:

Etichetta GOTO;

Qui, etichetta è l'identificatore dell'affermazione a cui si desidera saltare. È essenziale notare che l'uso eccessivo dell'istruzione Goto può rendere il tuo codice più difficile da leggere e mantenere.

Esempio: usando l'istruzione Goto

Seguendo il codice spiegare l'utilizzo di "vai a" Dichiarazione in C#.

usando il sistema;
Consolepplication dello spazio dei nomi

Programma di classe

statico void main (string [] args)

Console.WriteLine ("Goto inizia");
Etichetta GOTO;
Console.WriteLine ("Questa linea sarà saltata");
etichetta:
Console.WriteLine ("questa riga verrà visualizzata");
Console.Leggere();

Il programma inizia stampando "Goto inizia" alla console usando il file Console.Linea di scrittura() metodo.

Successivamente, il programma utilizza la dichiarazione "Goto" per saltare a una dichiarazione etichettata chiamata "etichetta". Poiché l'istruzione "Goto" trasferisce il controllo all'etichetta specificata, l'esecuzione del programma salta il Console.Linea di scrittura() Dichiarazione che segue la dichiarazione "Goto" e salta direttamente all'istruzione etichettata.

Le stampe di istruzione etichettate "Questa riga verrà visualizzata"Alla console usando la console.Metodo WriteLine (). Infine, il programma attende l'input dell'utente utilizzando il Console.Leggere() metodo.

Quando l'utente inserisce qualsiasi input, il programma esce.

2: Break Dichiarazione in C#

Per uscire da un ciclo o di interruttore in C# A rottura viene utilizzata la dichiarazione. Dopo aver utilizzato un'istruzione di interruzione, l'istruzione Loop o Switch viene immediatamente terminato e il controllo viene trasferito all'istruzione seguendola.

Di seguito è il sintassi della dichiarazione di pausa in C#:

rottura;

L'istruzione di interruzione viene utilizzata all'interno di un'istruzione Loop o Switch. Dopo l'esecuzione dell'istruzione di interruzione, il controllo del programma viene consegnato al ciclo che si trova accanto ad esso. Si noti che quando ci sono più loop nidificati insieme, l'istruzione di pausa uscirà solo alla singola iterazione del loop.

Esempio: usando l'istruzione di pausa

Di seguito è riportato un codice di esempio che dimostra l'uso dell'istruzione di rottura in c#.

usando il sistema;
Consolepplication dello spazio dei nomi

Programma di classe

statico void main (string [] args)

per (int i = 1; i <= 10; i++)

if (i == 5)
rottura;
Console.WriteLine ("Value of I is 0", i);

Console.Leggere();

Il codice sopra inizia definendo a per Loop che inizia l'iterazione da 1 e termina a 10. Per ogni iterazione il loop per verificherà il valore 5 utilizzando l'istruzione IF. Una volta che il Loop raggiunge il numero 5 viene eseguita l'istruzione di interruzione, che termina il loop e salta alla dichiarazione successiva dopo il loop.

Altrimenti, se il per loop Il valore non è uguale a 5, il ciclo esegue il Console.Linea di scrittura() metodo, che stampare il valore corrente di io alla console nel formato "Valore di I è 0". Questa riga viene eseguita per ogni iterazione del loop dove io non è uguale a 5.

Alla fine Console.Leggere() Aspetterò la risposta dell'utente dopo che il programma esce.

3: Continua la dichiarazione in C#

In C# L'istruzione Continua salterà l'iterazione in esecuzione per un ciclo e passerà alla prossima iterazione. Viene in genere utilizzato per saltare valori o condizioni specifiche che non si desidera elaborare nel tuo loop.

IL sintassi Per l'utilizzo dell'istruzione Continua in C# è la seguente:

Continua;

Quando utilizziamo un'istruzione Continua all'interno di un loop, salterà alcune parti di codice su condizioni specifiche e imposterà il controllo del programma all'inizio del ciclo. In parole semplici questa dichiarazione di salto salterà qualsiasi codice rimanente e imposterà il puntatore per avviare il loop.

Esempio: utilizzando l'istruzione Continua

Di seguito è riportato un esempio di dichiarazione continua in c#.

usando il sistema;
Consolepplication dello spazio dei nomi

Programma di classe

statico void main (string [] args)

per (int i = 1; i <= 5; i++)

if (i == 3)
Continua;
Console.WriteLine ("Value of I is 0", i);

Console.Leggere();

Questo codice utilizza un file per Loop che inizia con io impostare su 1 e iterate finché io è inferiore o uguale a 5. Per ogni iterazione, il ciclo controlla se io è uguale a 3 usando l'istruzione IF. Quando il ciclo raggiunge il valore pari a 3 allora Continua la dichiarazione sarà eseguito. Questo salterà tutte le altre dichiarazioni definite all'interno del ciclo per questa particolare iterazione che è i = 3 e procede alla prossima iterazione.

Altrimenti, se io non è uguale a 3, il ciclo esegue il Console.Linea di scrittura() metodo, che stampare il valore corrente di io alla console nel formato "Valore di I è 0". Questa riga viene eseguita per ogni iterazione del loop dove io non è uguale a 3.

Alla fine Console.Leggere() Aspetterò l'input dell'utente dopo l'uscita del programma.

4: Dichiarazione di ritorno in C#

L'istruzione di ritorno in C# restituisce una funzione o un valore del metodo. Termina l'esecuzione della funzione o del metodo e fornisce il valore specifico al codice chiamata.

IL sintassi Per l'utilizzo dell'istruzione di ritorno in C# è la seguente:

restituire [val];

Qui, "Val" è il valore che si desidera restituire dalla funzione o dal metodo. Se l'istruzione di ritorno viene utilizzata in un metodo che non restituisce un valore (vuoto), la restituzione della parola chiave viene utilizzata senza un valore.

Esempio: utilizzando l'istruzione di ritorno

Questo è un codice C# che spiega l'utilizzo delle dichiarazioni di restituzione.

usando il sistema;
Programma di classe

statico int add (numero int)

int risultato = numero + numero;
risultato di ritorno;

statico void main (string [] args)

int num = 5;
int risultato = add (num);
Console.WriteLine ("La somma di 0 e 0 è: 1", num, risultato);
Console.Leggere();

Il programma definisce un metodo chiamato Aggiungere() Ciò richiede un numero di parametro intero, aggiunge un numero a se stesso e restituisce il risultato.

Nel principale (), un numero variabile viene inizializzato su 5 e il metodo Add () viene chiamato con Num come argomento. IL ritorno valore di Aggiungere() è assegnato a un risultato variabile. Finalmente il Console.Linea di scrittura() Il metodo viene utilizzato per stampare un messaggio alla console che include il valore originale di NUM e il risultato dell'aggiunta.

Nel complesso, questo programma mostra come un metodo può eseguire un calcolo e restituire un valore che può essere utilizzato nel codice chiamante. L'istruzione di ritorno uscirà dal programma e restituirà un output al chiamante.

5: Dichiarazione di lancio in C#

La dichiarazione di lancio è un altro tipo di dichiarazione di salto in C# che può aumentare un'eccezione. Le eccezioni includono l'errore che arriva quando il programma viene eseguito e questi errori fanno sì che il programma termina in modo imprevisto o produca risultati errati.

Dopo aver lanciato un'eccezione, il runtime cerca un blocco di cattura in grado di gestire l'eccezione. Se viene trovato un blocco di cattura, il controllo viene trasferito a quel blocco e l'eccezione viene gestita. Se non viene trovato alcun blocco di cattura, il codice si chiuderà con la visualizzazione di un messaggio di errore.

La dichiarazione di lancio sintassi è semplice. Per lanciare un'eccezione, usi semplicemente la parola chiave di lancio seguita dall'oggetto eccezione che si desidera lanciare. Ecco un esempio:

lanciare e;

Una parola chiave di lancio viene utilizzata qui per lanciare un'eccezione "E" che deriva dalla classe di eccezione.

Esempio: usando l'istruzione Throw

Ecco un programma C# Esempio che spiega l'utilizzo delle dichiarazioni di lancio.

usando il sistema;
Programma di classe
statico void main (string [] args)
int num1 = 10;
int num2 = 0;
Tentativo
if (num2 == 0)
lancia un nuovo dividyzeroexception ("Impossibile dividere per zero.");

int risultato = num1 / num2;
Console.WriteLine ("Risultato:" + risultato);
catch (DivideByZeroException e)
Console.WriteLine ("Errore:" + E.Messaggio);

In questo programma, stiamo cercando di dividere Num1 di Num2, Ma abbiamo aggiunto un blocco di cattura per gestire la possibilità di un DivideByZeroException essere lanciato.

All'interno del blocco di prova, controlliamo se Num2 è uguale a 0 e quando questa condizione diventa vera, lanciamo una DivideByZeroException con il messaggio "Non può dividere per zero".

Se non viene lanciata alcuna eccezione, il risultato della divisione verrà calcolato e stampato sulla console.

Se viene lanciata un'eccezione, il blocco catch la gestirà catturando DividebyzeroException e producendo il messaggio di errore alla console.

Conclusione

Le dichiarazioni di salto sono una parte cruciale dei linguaggi di programmazione tra cui C#. In questo articolo, abbiamo esaminato i diversi tipi di dichiarazioni di salto in C#, come funzionano e quando usarli. Tuttavia, l'uso delle dichiarazioni di salto, in particolare, non è raccomandato in quanto possono cambiare il flusso del programma e rendere difficile la traccia.