Esercizio - Costruire dati di esempio e cicli di selezione di menu

25 minuti

In questo esercizio si esamina il codice nel progetto starter, si eseguono alcune attività di pulizia del codice e quindi si inizia ad aggiungere funzionalità all'applicazione. Le attività completate durante questo esercizio sono:

Revisione del codice: esaminare il contenuto del file Program.cs.
Dati di esempio: convertire la struttura if-elseif-else in una struttura switch-case che migliora la leggibilità.
Ciclo di menu: racchiudere il menu principale e la selezione delle voci di menu in un ciclo che scorre fino a quando l'utente non immette "exit".
Selezioni di menu: scrivere il codice per una struttura switch-case che stabilisce rami di codice separati per ogni opzione di menu.
Rami di codice: scrivere un segnaposto all'interno dei rami delle voci di menu che fornisce il feedback utente fino a quando non vengono sviluppate le funzionalità dell'app.
Test di verifica: eseguire test di verifica per il codice sviluppato in questo esercizio.

Esaminare il contenuto del file Program.cs

In questa attività viene completata una procedura dettagliata del codice del progetto Starter. Il file Program.cs contiene una versione preliminare dell'applicazione che si aggiorna durante questo modulo. Il codice esistente genera dati di esempio per l'applicazione e visualizza un elenco di opzioni di menu. Le opzioni di menu rappresentano le funzionalità principali dell'applicazione.

Assicurarsi che la cartella GuidedProject sia aperta in Visual Studio Code.

L'unità precedente include una sezione setup che descrive come aprire il progetto Starter. Se necessario, tornare indietro e seguire le istruzioni per la configurazione.
Nella visualizzazione EXPLORER espandere la cartella Starter e quindi selezionare Program.cs.

Quando si seleziona il file Program.cs, il contenuto del file viene aperto nell'editor di Visual Studio Code.

Se la visualizzazione EXPLORER non è aperta, selezionare EXPLORER dalla barra delle attività di Visual Studio Code. Il pulsante EXPLORER si trova nella parte superiore della barra delle attività.
Dedicare alcuni minuti alla revisione del codice nel file Program.cs.
Si noti che la parte superiore del codice inizia con alcune dichiarazioni di variabili.
```
// the ourAnimals array will store the following: 
string animalSpecies = "";
string animalID = "";
string animalAge = "";
string animalPhysicalDescription = "";
string animalPersonalityDescription = "";
string animalNickname = "";

// variables that support data entry
int maxPets = 8;
string? readResult;
string menuSelection = "";

// array used to store runtime data, there is no persisted data
string[,] ourAnimals = new string[maxPets, 6];
```
Nella parte superiore del file viene visualizzata una riga di commento e un elenco di variabili. Queste variabili, animalSpecies tramite animalNickname, vengono usate per contenere i valori delle caratteristiche dell'animale domestico. Più avanti nel codice si assegnano i valori delle caratteristiche a una matrice di stringhe multidimensionali denominata ourAnimals. Ognuna di queste variabili viene inizializzata per contenere una stringa ""di lunghezza zero. La ourAnimals matrice viene dichiarata un po' più avanti nel codice.

Il gruppo successivo di variabili è una combinazione di string variabili e int che verranno usate per generare dati di esempio, leggere l'input dell'utente e stabilire criteri di uscita per il ciclo di programma principale. È possibile che sia stata notata la riga string? readResult;di codice . Se usato in una dichiarazione di variabile come questo, il ? carattere definisce una variabile di tipo nullable. Quando si leggono i valori immessi dall'utente con il Console.ReadLine() metodo , è consigliabile usare un tipo nullable.

La variabile finale è una matrice di stringhe bidimensionale denominata ourAnimals. Poiché si crea un'istanza della matrice senza inizializzare alcun valore, si usa l'operatore new (l'operatore new viene usato per creare una nuova istanza di un tipo). Il numero di righe è definito da maxPets, che è stato inizializzato su otto. Il numero di caratteristiche archiviate è sei, ovvero le variabili stringa esaminate in precedenza.
Scorri verso il basso per esaminare il for ciclo contenente un if-elseif-else costrutto di selezione.

Annotazioni

Se visualizzi un'istruzione switch invece di un'istruzione if-elseif-else all'interno del blocco di codice del ciclo for, assicurati di esaminare il file Program.cs nella cartella Starter, non il file Program.cs nella cartella Final. Non si vuole apportare modifiche al codice nella cartella Finale. Potrebbe essere necessario usare la cartella Finale come riferimento più avanti in questo modulo.
Si noti che il for ciclo usa la maxPets variabile per stabilire un limite superiore sul numero di iterazioni.
Nota che il costrutto if-elseif-else dirama in modo selettivo il codice in base alle caratteristiche degli animali domestici.

Il if-elseif-else costrutto viene usato per definire valori diversi per le prime quattro iterazioni del for ciclo. Dopo la quarta iterazione, a tutte le caratteristiche viene assegnata una stringa vuota o di lunghezza zero.

I valori delle variabili delle caratteristiche degli animali vengono assegnati all'array ourAnimals nella parte inferiore del ciclo for.
Scorrere fino alla fine del file di codice, quindi esaminare il codice usato per visualizzare le opzioni di menu e leggere la selezione dell'utente.
Si noti che si assegna il valore restituito dal Console.ReadLine() metodo alla stringa nullable readResult.

L'uso di una stringa nullable è la procedura consigliata per acquisire l'input dal metodo ReadLine(). Dopo aver verificato che il valore di input non è Null, assegnare il valore a una variabile stringa standard denominata menuSelection. Questo processo consente di valutare il valore di selezione del menu senza preoccuparsi dei valori Null. Molti dei metodi che accettano stringhe come parametro di input genereranno un errore se vengono passati un valore Null. Se non si segue questo modello di input, è probabile che il compilatore di codice generi un avviso quando si compila il progetto.

Le righe finali del file Program.cs riecheggiano la selezione delle opzioni di menu e quindi sospendono l'esecuzione fino a quando non viene premuto Invio.

Convertire un'istruzione if in un'istruzione switch

In questa attività si converte il costrutto esistente if-elseif-else in un costrutto switch-case. Un'istruzione switch migliora la leggibilità del codice.

Fai scorrere verso l'alto fino all'inizio del ciclo for usato per generare i dati di esempio.

Si noti che il if-elseif-else costrutto inizia con la seguente istruzione e blocco di codice if:

if (i == 0)
{
    animalSpecies = "dog";
    animalID = "d1";
    animalAge = "2";
    animalPhysicalDescription = "medium sized cream colored female golden retriever weighing about 65 pounds. housebroken.";
    animalPersonalityDescription = "loves to have her belly rubbed and likes to chase her tail. gives lots of kisses.";
    animalNickname = "lola";
}

Sostituire l'istruzione iniziale if e il blocco di codice con il codice seguente:

switch (i)
{
    case 0:
        animalSpecies = "dog";
        animalID = "d1";
        animalAge = "2";
        animalPhysicalDescription = "medium sized cream colored female golden retriever weighing about 65 pounds. housebroken.";
        animalPersonalityDescription = "loves to have her belly rubbed and likes to chase her tail. gives lots of kisses.";
        animalNickname = "lola";
        break;

Il case 0: codice esegue la stessa selezione della if (i == 0) selezione che sostituisce. Effettuerai le sostituzioni corrispondenti per completare la conversione dal costrutto if-elseif-else a un costrutto switch-case.

Si noti che ora viene visualizzato il simbolo di una linea rossa ondulata sotto ; alla fine dell'istruzione break.

Visual Studio Code usa una linea ondulata rossa per individuare i problemi nel codice. In questo caso, esistono alcuni problemi. In primo luogo, non hai chiuso il blocco di codice per l'istruzione switch. Inoltre, hai un else if senza il if, il che non è consentito. Ognuno di questi problemi viene risolto durante il completamento della conversione da un if oggetto a un oggetto switch.

Sostituire l'istruzione else if (i == 1) e il blocco di codice con il codice seguente.

case 1:
    animalSpecies = "dog";
    animalID = "d2";
    animalAge = "9";
    animalPhysicalDescription = "large reddish-brown male golden retriever weighing about 85 pounds. housebroken.";
    animalPersonalityDescription = "loves to have his ears rubbed when he greets you at the door, or at any time! loves to lean-in and give doggy hugs.";
    animalNickname = "loki";
    break;

Sostituire l'istruzione else if (i == 2) e il blocco di codice con il codice seguente.

case 2:
    animalSpecies = "cat";
    animalID = "c3";
    animalAge = "1";
    animalPhysicalDescription = "small white female weighing about 8 pounds. litter box trained.";
    animalPersonalityDescription = "friendly";
    animalNickname = "Puss";
    break;

Sostituire l'istruzione else if (i == 3) e il blocco di codice con il codice seguente.

case 3:
    animalSpecies = "cat";
    animalID = "c4";
    animalAge = "?";
    animalPhysicalDescription = "";
    animalPersonalityDescription = "";
    animalNickname = "";
    break;

Sostituire l'istruzione else e il blocco di codice con il codice seguente.

default:
    animalSpecies = "";
    animalID = "";
    animalAge = "";
    animalPhysicalDescription = "";
    animalPersonalityDescription = "";
    animalNickname = "";
    break;

}

Si noti che il costrutto if-elseif-else ora è stato completamente sostituito da un costrutto switch-case e che il simbolo della linea ondulata rossa non è più presente.

Se parti del tuo costrutto if-elseif-else sono ancora presenti, o se la tua istruzione switch è incompleta, verifica se hai saltato un passaggio.
Il tuo costrutto completato switch-case dovrebbe avere una struttura simile al seguente codice:

Annotazioni

Le variabili usate per assegnare i valori delle caratteristiche degli animali domestici sono state rimosse dall'esempio di codice seguente per abbreviare il numero di righe di codice. Il codice deve includere le assegnazioni di variabili stringa per ogni modello di case, incluso il caso predefinito.
```
switch (i)
{
    case 0:
        // variable assignments were removed for this view of the structure
        break;

    case 1:
        // variable assignments were removed for this view of the structure
        break;

    case 2:
        // variable assignments were removed for this view of the structure
        break;

    case 3:
        // variable assignments were removed for this view of the structure
        break;

    default:
        // variable assignments were removed for this view of the structure
        break;
}
```
Tenere presente che il "fall-through" dell'esecuzione di una sezione switch in quella successiva non è consentito. L'istruzione break viene usata per assicurarsi che non si verifichi il "fall-through".
Nel menu File di Visual Studio Code, selezionare Salva.
Nella vista Esplora, fare clic con il pulsante destro del mouse su Starter e quindi scegliere Apri nel terminale integrato.

Sotto l'area dell'editor di codice si dovrebbe aprire un pannello TERMINALE.

Esistono diversi modi per aprire il terminale integrato di Visual Studio Code. Ad esempio, il menu in alto consente di accedere al pannello TERMINALE dal menu Visualizza e dal menu Terminale. È anche possibile usare i tasti di scelta rapida per aprire il pannello TERMINALE. Ogni metodo è accettabile.
Nota che il pannello TERMINALE include un prompt della riga di comando e che il prompt mostra il percorso della cartella corrente.

Per esempio:
```
C:\Users\someuser\Desktop\GuidedProject\Starter>
```
È possibile usare il pannello TERMINALE per eseguire i comandi dell'interfaccia della riga di comando, ad esempio dotnet build e dotnet run. Il comando dotnet build compilerà il codice e visualizzerà i messaggi di errore e di avviso correlati alla sintassi del codice.

Importante

È necessario assicurarsi che il prompt dei comandi del terminale sia aperto alla directory principale dell'area di lavoro del progetto. In questo caso, la radice dell'area di lavoro del progetto è la cartella Starter, in cui si trovano i file Starter.csproj e Program.cs. Quando si eseguono comandi nel terminale, i comandi eseguiranno azioni usando il percorso corrente della cartella. Se si esegue il dotnet build comando o dotnet run da un percorso di cartella che non contiene i file, il comando genererà messaggi di errore.
Al prompt dei comandi del TERMINALE immettere il comando seguente per compilare il codice del progetto: dotnet build

Dopo un paio di secondi, verrà visualizzato un messaggio che informa che la compilazione è riuscita e che sono presenti 0 avvisi e 0 errori.
```
Determining projects to restore...
All projects are up-to-date for restore.
Starter -> C:\Users\someuser\Desktop\GuidedProject\Starter\bin\Debug\net10.0\Starter.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)
```
Se vengono visualizzati messaggi di errore o di avviso, è necessario correggerli prima di continuare.

I messaggi di errore e avviso indicano la riga di codice in cui è possibile trovare il problema. Di seguito è riportato un esempio di messaggio di errore Build FAILED:

C:\Users\someuser\Desktop\GuidedProject\Starter\Program.cs(53,18): error CS1002: ; expected [C:\Users\someuser\Desktop\GuidedProject\Starter\Starter.csproj]

Questo messaggio indica il tipo di errore rilevato e dove trovarlo. In questo caso, il messaggio indica che il file Program.cs contiene un errore, error CS1002: ; expected. ; expected suggerisce che hai dimenticato di includere un ; alla fine di un'istruzione. La parte Program.cs(53,18) del messaggio indica che l'errore si trova nella riga di codice 53, in una posizione a 18 caratteri di distanza da sinistra.

Un errore di sintassi simile a questo impedisce la riuscita della compilazione (Compilazione NON RIUSCITA). Alcuni messaggi di compilazione riportano un Avviso anziché un Errore, segnalando che c'è qualcosa da verificare, ma che è possibile provare a eseguire comunque il programma (Compilazione completata).

Dopo aver risolto i problemi e salvato gli aggiornamenti, è possibile eseguire di nuovo il comando dotnet build. Continuare fino a quando non sono presenti 0 avvisi e 0 errori.

Annotazioni

Se non si riesce a risolvere un problema autonomamente, è possibile esaminare il codice di Program.cs nella cartella Final inclusa nel download completato durante la configurazione. Il codice Program.cs nella cartella Finale rappresenta la conclusione di tutti gli esercizi in questo modulo, quindi includerà il codice che non è ancora stato creato. Può essere molto diverso dal codice Program.cs sviluppato a questo punto nel progetto guidato. Tuttavia, è possibile provare a esaminare il codice Program.cs in Final per isolare e risolvere un problema nel codice. Evitare di usare il codice nella cartella Finale come guida. Tenere presente che gli sviluppatori imparano dagli errori e che ogni sviluppatore dedica tempo a trovare e correggere gli errori.
Chiudere il pannello Terminale.

In questa attività, costruisci un ciclo che racchiude le opzioni di menu e il codice che legge l'input dell'utente. Questo ciclo garantisce che il menu principale venga aggiornato per l'utente ogni volta che effettua una selezione di menu. Questo ciclo scorre fino a quando l'utente non sceglie di uscire dal programma.

Nell'editor di Visual Studio Code, nella parte superiore del codice usato per visualizzare le opzioni di menu, individuare il commento seguente:
```
// display the top-level menu options
```
Creare una riga di codice vuota sopra il commento e quindi immettere il codice seguente:
```
do
{
```
Racchiudendo le opzioni di menu del programma all'interno di un do ciclo, assicurarsi che l'utente visualizzi le opzioni di menu almeno una volta.
Scorrere verso il basso fino alla fine del file di codice.
Creare una riga di codice vuota sotto il codice che sospende l'esecuzione del codice e quindi aggiornare il codice nel modo seguente:
```
// pause code execution
readResult = Console.ReadLine();

} while ();
```
Nota che hai chiuso il blocco di codice per il ciclo do e hai iniziato a costruire la tua istruzione while.
Per specificare l'espressione booleana valutata dall'istruzione while , aggiornare l'istruzione while nel modo seguente:
```
while (menuSelection != "exit");
```
Questa espressione garantisce che il do ciclo continui fino a quando l'utente sceglie "Esci" dall'applicazione. Ogni iterazione visualizzerà il menu e leggerà la selezione del menu dell'utente.
Si noti che il rientro della riga di codice non è quello che ci si aspetta all'interno del blocco di codice del ciclo do.
Per fare in modo che Visual Studio Code "corregga" il rientro delle righe di codice, fare clic con il pulsante destro del mouse all'interno dell'editor di codice e quindi scegliere Formatta documento.

Oltre all'indentazione corretta delle righe di codice, il comando Formatta documento applicherà altre regole di formattazione del codice. Tuttavia, non corregge gli errori di sintassi nel codice e può avere risultati imprevisti se il codice include blocchi di codice incompleti o in formato non valido. Il comando Formatta documento è utile purché si stia attenti.

I tasti di scelta rapida per richiamare questo comando sono:
- In Windows MAIUSC+ALT+F
- In Mac MAIUSC+OPZIONE+F
- Su Linux ctrl + shift + I
Questo comando è disponibile anche usando il riquadro comandi. Per trovare il comando Formatta documento dal riquadro comandi:
- Nel menu Visualizza, selezionare Riquadro comandi e quindi immettere Formatta D al prompt.
- L'elenco filtrato dei comandi mostrerà Formatta documento come comando selezionabile
Nel menu File di Visual Studio Code, selezionare Salva.
Aprire il pannello Terminale integrato.

È possibile aprire il pannello Terminale facendo clic con il pulsante destro del mouse sulla cartella Starter in EXPLORER e quindi scegliendo Apri nel terminale integrato.
Al prompt dei comandi del terminale immettere il dotnet build comando per compilare il codice aggiornato.

Verrà visualizzato un messaggio che segnala 0 avvisi e 0 errori
Correggere eventuali errori di compilazione o avvisi segnalati prima di continuare.
Nel prompt dei comandi del Terminale, immettere il comando dotnet run per eseguire il codice aggiornato.

L'applicazione inizierà l'esecuzione.

Verificare che le opzioni del menu principale siano visualizzate nel pannello Terminale come previsto.

Nel pannello TERMINALE verrà visualizzato quanto segue.

Welcome to the Contoso PetFriends app. Your main menu options are:
1. List all of our current pet information
2. Add a new animal friend to the ourAnimals array
3. Ensure animal ages and physical descriptions are complete
4. Ensure animal nicknames and personality descriptions are complete
5. Edit an animal's age
6. Edit an animal's personality description
7. Display all cats with a specified characteristic
8. Display all dogs with a specified characteristic

Enter your selection number (or type Exit to exit the program)

Al prompt dei comandi del terminale, per selezionare l'opzione di menu 1, immettere 1

Se l'app è sospesa con il cursore posizionato a destra di "1", premere invio. Per immettere il valore, è necessario premere INVIO dopo aver digitato il carattere 1 .
Assicurati che il tuo codice riporti la selezione del menu che hai inserito.

Nel terminale verrà visualizzato l'output seguente.
```
You selected menu option 1.
Press the Enter key to continue
```
Se questo messaggio non viene visualizzato, assicurarsi di aver salvato gli aggiornamenti del codice prima di eseguire il dotnet build comando. Se necessario, salvare il codice e quindi provare a eseguire nuovamente l'applicazione.
Al prompt dei comandi del terminale premere INVIO per continuare.

Premendo INVIO è possibile che il codice proceda oltre il Console.ReadLine() metodo che si trova prima che l'espressione while venga valutata alla fine dell'applicazione.
Per verificare che il codice continui ad accettare selezioni di menu aggiuntive, provare a immettere uno o più numeri di voci di menu.

Se l'esecuzione del codice è stata interrotta dopo l'immissione di "1", assicurarsi di aver salvato gli aggiornamenti del codice. Se necessario, salvare il codice e quindi provare a eseguire nuovamente l'applicazione.

È possibile notare che è possibile immettere qualsiasi testo o valore numerico o anche una combinazione di lettere e numeri. Questo problema verrà risolto quando si sviluppa il codice che gestisce l'input dell'utente.
Al prompt dei comandi del terminale, per verificare che i criteri di uscita per il ciclo vengano valutati correttamente, immettere Exit o exit.

Quando si immette "Exit" o "exit", l'espressione while deve restituire false e l'esecuzione del codice deve terminare.

Importante

Se l'esecuzione del codice non si arresta come previsto quando si immette "exit", è possibile premere CTRL+C nel terminale integrato per forzare l'arresto dell'esecuzione del codice.
Chiudere il pannello Terminale.

In questa attività si scrive il codice per un'istruzione switch che dirama l'esecuzione del codice in base al valore assegnato a menuSelection. Si crea un'etichetta switch che corrisponde a ogni numero di voce di menu. La creazione di etichette separate switch garantisce che ogni voce di menu venga gestita separatamente. Un'istruzione switch è una buona soluzione di implementazione della logica prevista dell'applicazione.

Nell'editor di Visual Studio Code individuare la riga di codice seguente Console.WriteLine() usata per ripetere la selezione del menu.
```
Console.WriteLine($"You selected menu option {menuSelection}.");
```

Per iniziare a sviluppare l'istruzione switch, aggiorna il codice nel modo seguente:

//Console.WriteLine($"You selected menu option {menuSelection}.");
//Console.WriteLine("Press the Enter key to continue");

// pause code execution
//readResult = Console.ReadLine();

switch(menuSelection)
{

}

Per aggiungere il primo case modello all'istruzione switch, aggiorna il codice dell'istruzione switch come segue:
```
switch(menuSelection)
{
    case "1":
        break;

}
```
Avrai notato che il modello di maiuscole/minuscole usato qui è leggermente diverso dal modello utilizzato durante la creazione dei dati di esempio precedentemente nell'applicazione (case 1: rispetto a case "1":). La spiegazione è semplice. È stato eseguito il controllo dei valori interi in precedenza e ora si stanno controllando i valori stringa.

Per creare rami di selezione nel switch-case costrutto per ognuno dei numeri di selezione dei menu rimanenti, aggiungere opzioni aggiuntive case come indicato di seguito:

switch(menuSelection)
{
    case "1":
        break;

    case "2":
        break;

    case "3":
        break;

    case "4":
        break;

    case "5":
        break;

    case "6":
        break;

    case "7":
        break;

    case "8":
        break;

}

Si noti che è possibile aggiungere il caso facoltativo default alla fine dell'elenco di selezione come indicato di seguito:

switch(menuSelection)
{
    // case selections 1-7 have been removed to simplify this sample code 

    case "8":
        break;

    default:
        break;
}

Nel menu File di Visual Studio Code, selezionare Salva.
Aprire il pannello Terminale integrato e quindi eseguire il comando per compilare il programma.

Usare il dotnet build comando per compilare il codice aggiornato.

Verrà visualizzato il messaggio che segnala 0 avvisi e 0 errori
Correggere eventuali errori di compilazione o avvisi segnalati prima di continuare.
Chiudere il pannello Terminale.

Scrivere codice segnaposto per ogni caso dell'istruzione switch

In questa attività si aggiornano i percorsi di esecuzione del codice creati dall'istruzione switch . Al termine, ogni switch sezione fornirà un feedback all'utente che conferma la selezione del menu. Fornire commenti e suggerimenti che riconoscono l'input dell'utente è particolarmente importante perché non sarà possibile completare il codice per tutte le opzioni di menu durante questo modulo. Il feedback consente all'utente di sapere che il codice ha riconosciuto il proprio input, anche se l'applicazione non è in grado di elaborare la richiesta.

Nell'editor di Visual Studio Code individuare la riga di codice contenente la case "1": selezione:
```
switch (menuSelection)
{
    case "1":
        break;
```

Per fornire un messaggio di feedback all'utente tra le righe di case "1": codice e break; , aggiornare il codice nel modo seguente:

switch (menuSelection)
{
    case "1":
        // List all of our current pet information
        Console.WriteLine("this app feature is coming soon - please check back to see progress.");
        Console.WriteLine("Press the Enter key to continue.");
        readResult = Console.ReadLine();
        break;

Aggiungere lo stesso messaggio di feedback per la case "2": selezione come indicato di seguito:

switch (menuSelection)
{
    case "1":
        // List all of our current pet information
        Console.WriteLine("this app feature is coming soon - please check back to see progress.");
        Console.WriteLine("Press the Enter key to continue.");
        readResult = Console.ReadLine();
        break;

    case "2":
        // List all of our current pet information
        Console.WriteLine("this app feature is coming soon - please check back to see progress.");
        Console.WriteLine("Press the Enter key to continue.");
        readResult = Console.ReadLine();
        break;

Aggiornare il commento della riga per la selezione case "2": in base alla seconda opzione di menu come di seguito indicato:

case "2":
    // Add a new animal friend to the ourAnimals array
    Console.WriteLine("this app feature is coming soon - please check back to see progress.");
    Console.WriteLine("Press the Enter key to continue.");
    readResult = Console.ReadLine();
    break;

Per le selezioni da case "3": a case "8":, aggiorna il codice con un commento in linea che rifletta il testo della voce di menu associata.

Ad esempio, aggiungere // Ensure animal ages and physical descriptions are complete di seguito case "3":

È possibile copiare il testo della voce di menu dalle righe di codice che visualizzano le opzioni di menu.

Annotazioni

È possibile usare il comando "Formatta documento" per pulire la formattazione. Ciò può velocizzare il lavoro e dedicare più tempo a concentrarsi sul codice immesso anziché sul modo in cui viene visualizzato.

Per le selezioni case "3": e case "4":, aggiungere il messaggio di feedback seguente e ReadLine() sotto il commento di riga.

Console.WriteLine("Challenge Project - please check back soon to see progress.");
Console.WriteLine("Press the Enter key to continue.");
readResult = Console.ReadLine();

Per le selezioni rimanenti case, aggiorna il codice usando il seguente messaggio di feedback e ReadLine():
```
Console.WriteLine("UNDER CONSTRUCTION - please check back next month to see progress.");
Console.WriteLine("Press the Enter key to continue.");
readResult = Console.ReadLine();
```
Annotazioni

Se è stato aggiunto il caso default facoltativo all'elenco di selezioni, non aggiungere il messaggio di feedback a tale caso.
Nel menu File di Visual Studio Code, selezionare Salva.

Tenere presente che Visual Studio Code formatta il codice se si fa clic con il pulsante destro del mouse all'interno dell'editor di codice e quindi scegliere Formatta documento dal menu di scelta rapida.
Aprire il pannello Terminale integrato e quindi eseguire il comando per Compilare il programma.

Usare il dotnet build comando per compilare il codice aggiornato.
Correggere eventuali errori di compilazione o avvisi segnalati prima di continuare.

Controlla il tuo lavoro

In questa attività si esegue l'applicazione dal terminale integrato e si verifica che l'istruzione switch dirama il codice come previsto. Verificare anche che i messaggi di feedback previsti vengano visualizzati per ogni selezione di menu. Anche i criteri di uscita per il ciclo di menu principale verranno ritestati.

Se necessario, aprire il pannello Terminale integrato di Visual Studio Code.
Al prompt dei comandi del terminale immettere dotnet run
Al prompt dei comandi del terminale, per selezionare la prima opzione di menu, immettere 1
Verificare che venga visualizzato il messaggio "presto disponibile" previsto.
Ripetere il passaggio precedente, immettendo ognuno degli altri numeri di opzione di menu per verificare che il messaggio previsto venga visualizzato in ogni caso.
Al prompt dei comandi del terminale immettere Esci o esci per verificare che i criteri di uscita siano ancora valutati correttamente.

Importante

Se l'esecuzione del codice non si arresta come previsto, è possibile premere CTRL-C nel terminale integrato per forzare l'arresto dell'esecuzione.
Chiudere il pannello Terminale.

Commenti e suggerimenti

Questa pagina è stata utile?