Delen via

C#- if instructies en -lussen - zelfstudie over voorwaardelijke logica

  • Artikel

In deze zelfstudie leert u hoe u C#-code schrijft waarmee variabelen worden onderzocht en het uitvoeringspad wordt gewijzigd op basis van deze variabelen. U schrijft C#-code en ziet de resultaten van het compileren en uitvoeren ervan. De zelfstudie bevat een reeks lessen die vertakkings- en lusconstructies in C# verkennen. In deze lessen krijgt u uitleg over de basisprincipes van de computertaal C#.

Tip

Als u een codefragment in de focusmodus wilt plakken, gebruikt u de sneltoets (Ctrl + v of cmd + v).

Vereisten

In de zelfstudie wordt verwacht dat u een computer hebt ingesteld voor lokale ontwikkeling. Zie Uw lokale omgeving instellen voor installatie-instructies en een overzicht van toepassingsontwikkeling in .NET.

Als u de code liever uitvoert zonder dat u een lokale omgeving hoeft in te stellen, raadpleegt u de interactieve versie van deze zelfstudie.

Beslissingen nemen met behulp van de if instructie

Maak een map met de naam branches-tutorial. Maak de huidige map en voer de volgende opdracht uit:

dotnet new console -n BranchesAndLoops -o .

Belangrijk

De C#-sjablonen voor .NET 6 gebruiken instructies op het hoogste niveau. Uw toepassing komt mogelijk niet overeen met de code in dit artikel als u al een upgrade naar .NET 6 hebt uitgevoerd. Zie het artikel over Nieuwe C#-sjablonen voor het genereren van instructies op het hoogste niveau voor meer informatie

De .NET 6 SDK voegt ook een set implicieteglobal using instructies toe voor projecten die gebruikmaken van de volgende SDK's:

  • Microsoft.NET.Sdk
  • Microsoft.NET.Sdk.Web
  • Microsoft.NET.Sdk.Worker

Deze impliciete global using instructies bevatten de meest voorkomende naamruimten voor het projecttype.

Zie het artikel over impliciete gebruiksrichtlijnen voor meer informatie

Met deze opdracht maakt u een nieuwe .NET-consoletoepassing in de huidige map. Open Program.cs in uw favoriete editor en vervang de inhoud door de volgende code:

int a = 5;
int b = 6;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10.");

Probeer deze code door in het consolevenster te typen dotnet run . Het bericht 'Het antwoord is groter dan 10', wordt weergegeven op de console. Wijzig de declaratie van b zodanig dat de som lager is dan 10:

int b = 3;

Typ dotnet run opnieuw. Omdat het antwoord lager is dan 10, wordt er niets afgedrukt. De door u geteste voorwaarde is onwaar. U hebt geen uitvoerbare code, omdat u enkel een van de mogelijke vertakkingen voor een if-instructie hebt geschreven: de vertakking Waar.

Tip

Bij de verkenning van C# (of elke andere programmeertaal) zult u fouten maken bij het schrijven van code. De compiler zoekt en rapporteert de fouten. Bekijk de uitvoer van de fout en de code die de fout heeft gegenereerd. De compilerfout kan u meestal helpen het probleem op te sporen.

In dit eerste voorbeeld ziet u de kracht van if booleaanse typen en . Een Booleaanse waarde is een variabele die een van de volgende twee waarden kan hebben: true of false. C# definieert een speciaal type, bool voor Booleaanse variabelen. Met de instructie if controleert u de waarde van een bool. Wanneer de waarde true is, wordt de instructie die op de if volgt, uitgevoerd. Anders wordt het overgeslagen. Dit proces voor het controleren van voorwaarden en het uitvoeren van instructies op basis van deze voorwaarden is krachtig.

Ervoor zorgen dat ‘if’ en ‘else’ in combinatie werken

Als u verschillende code in de vertakkingen Waar en Onwaar wilt uitvoeren, maakt u een else-vertakking die wordt uitgevoerd wanneer de voorwaarde onwaar is. Probeer een else vertakking. Voeg de laatste twee regels toe in de onderstaande code (u moet de eerste vier al hebben):

int a = 5;
int b = 3;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10");
else
    Console.WriteLine("The answer is not greater than 10");

De instructie die volgt op het sleutelwoord else, wordt alleen uitgevoerd wanneer de geteste voorwaarde false is. Het combineren van if en else met Booleaanse voorwaarden biedt alle kracht die u nodig hebt om zowel een als een truefalse voorwaarde te verwerken.

Belangrijk

De inspringing onder instructie if en else is voor menselijke lezers. De C#-taal behandelt inspringing of witruimte niet als significant. De instructie die volgt op het sleutelwoord if of else wordt uitgevoerd op basis van de voorwaarde. Alle voorbeelden in deze zelfstudie volgen een algemene procedure om regels te laten inspringen op basis van de controlestroom van -instructies.

Omdat inspringing niet significant is, moet u en gebruiken { om } aan te geven wanneer u wilt dat meer dan één instructie deel uitmaakt van het blok dat voorwaardelijk wordt uitgevoerd. C#-programmeurs gebruiken die accolades doorgaans voor alle if- en else-componenten. Het volgende voorbeeld is hetzelfde als het voorbeeld dat u hebt gemaakt. Wijzig de bovenstaande code zodat deze overeenkomt met de volgende code:

int a = 5;
int b = 3;
if (a + b > 10)
{
    Console.WriteLine("The answer is greater than 10");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
}

Tip

In de rest van deze zelfstudie bevatten de codevoorbeelden allemaal de accolades, volgens geaccepteerde procedures.

U kunt complexere voorwaarden testen. Voeg de volgende code toe na de code die u tot nu toe hebt geschreven:

int c = 4;
if ((a + b + c > 10) && (a == b))
{
    Console.WriteLine("The answer is greater than 10");
    Console.WriteLine("And the first number is equal to the second");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
    Console.WriteLine("Or the first number is not equal to the second");
}

Het == symbool test op gelijkheid. Met behulp == van wordt de gelijkheidstest onderscheiden van de toewijzing, die u hebt gezien in a = 5.

De && staat voor and. Dat wil zeggen dat beide voorwaarden waar moeten zijn om de instructie in de vertakking Waar uit te voeren. Deze voorbeelden geven tevens weer dat er meerdere instructies in een vertakking kunnen voorkomen, mits u deze omsluit met { en }. U kunt ook gebruiken || om 'of' weer te geven. Voeg de volgende code toe na wat u tot nu toe hebt geschreven:

if ((a + b + c > 10) || (a == b))
{
    Console.WriteLine("The answer is greater than 10");
    Console.WriteLine("Or the first number is equal to the second");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
    Console.WriteLine("And the first number is not equal to the second");
}

Wijzig de waarden van a, ben c en schakel tussen && en || om te verkennen. U krijgt meer inzicht in de werking van de && operators en || .

U hebt de eerste stap voltooid. Voordat u aan de volgende sectie begint, gaan we de huidige code naar een afzonderlijke methode verplaatsen. Dit maakt het gemakkelijker om aan de slag te gaan met een nieuw voorbeeld. Plaats de bestaande code in een methode met de naam ExploreIf(). Noem het vanaf de bovenkant van uw programma. Wanneer u klaar bent met deze wijzigingen, moet uw code er als volgt uitzien:

ExploreIf();

void ExploreIf()
{
    int a = 5;
    int b = 3;
    if (a + b > 10)
    {
        Console.WriteLine("The answer is greater than 10");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
    }

    int c = 4;
    if ((a + b + c > 10) && (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("And the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("Or the first number is not greater than the second");
    }

    if ((a + b + c > 10) || (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("Or the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("And the first number is not greater than the second");
    }
}

Maak commentaar bij de aanroep van ExploreIf(). Hierdoor wordt de uitvoer minder overzichtelijk terwijl u in deze sectie werkt:

//ExploreIf();

De // start een opmerking in C#. Opmerkingen zijn alle tekst die u in uw broncode wilt behouden, maar niet wilt uitvoeren als code. De compiler genereert geen uitvoerbare code op basis van opmerkingen.

Lussen gebruiken om bewerkingen te herhalen

In deze sectie gebruikt u lussen om instructies te herhalen. Voeg deze code toe na de aanroep naar ExploreIf:

int counter = 0;
while (counter < 10)
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
}

De while instructie controleert een voorwaarde en voert de instructie of instructieblok uit na de while. De voorwaarde wordt herhaaldelijk gecontroleerd en deze instructies worden uitgevoerd totdat de voorwaarde onwaar is.

Dit voorbeeld bevat nog een andere nieuwe operator. De ++ na de variabele counter is de verhogingsoperator. Hiermee wordt 1 toegevoegd aan de waarde van counter en wordt die waarde opgeslagen in de counter variabele.

Belangrijk

Zorg ervoor dat de while lusvoorwaarde verandert in false terwijl u de code uitvoert. Als dat niet het geval is, hebt u een oneindige lus gemaakt, zodat uw programma nooit wordt voltooid. Dat wordt niet in dit voorbeeld gedemonstreerd, omdat u moet afdwingen dat uw programma wordt afgesloten met ctrl-C of een andere methode.

Met de lus while wordt de voorwaarde getest voordat de code conform de while wordt uitgevoerd. Met de lus do ... while wordt eerst de code uitgevoerd en daarna de voorwaarde uitgevoerd. De do while-lus wordt weergegeven in de volgende code:

int counter = 0;
do
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
} while (counter < 10);

Deze do lus en de eerdere while lus produceren dezelfde uitvoer.

Werken met de lus ‘for’

De for-lus wordt vaak gebruikt in C#. Probeer deze code:

for (int index = 0; index < 10; index++)
{
    Console.WriteLine($"Hello World! The index is {index}");
}

De vorige code doet hetzelfde als de while lus en de do lus die u al hebt gebruikt. De instructie for bevat drie delen die de werking ervan regelen.

Het eerste deel is de for initializer: int index = 0; declareert dat index de lusvariabele is en stelt de beginwaarde in op 0.

Het middelste deel is de for-voorwaarde: index < 10 declareert dat deze for lus blijft worden uitgevoerd zolang de waarde van teller kleiner is dan 10.

Het laatste deel is de for iterator: index++ hiermee geeft u op hoe de lusvariabele moet worden gewijzigd na het uitvoeren van het blok na de for -instructie. Hier wordt opgegeven dat index steeds met 1 moet worden verhoogd als het blok wordt uitgevoerd.

Experimenteer zelf. Probeer elk van de volgende variaties:

  • Wijzig het initialisatieprogramma, zodat bij een andere waarde wordt gestart.
  • Wijzig de voorwaarde, zodat bij een andere waarde wordt gestopt.

Als u klaar bent, gaan we verder met het zelf schrijven van code, om toe te passen wat u hebt geleerd.

Er is nog een andere lusinstructie die niet wordt behandeld in deze zelfstudie: de foreach -instructie. De foreach instructie herhaalt de instructie voor elk item in een reeks items. Het wordt meestal gebruikt met verzamelingen, dus het wordt behandeld in de volgende zelfstudie.

Geneste lussen gemaakt

Een whilelus , doof for kan worden genest in een andere lus om een matrix te maken met behulp van de combinatie van elk item in de buitenste lus met elk item in de binnenste lus. Laten we dat doen om een set alfanumerieke paren te maken die rijen en kolommen vertegenwoordigen.

Eén for lus kan de rijen genereren:

for (int row = 1; row < 11; row++)
{
    Console.WriteLine($"The row is {row}");
}

Een andere lus kan de kolommen genereren:

for (char column = 'a'; column < 'k'; column++)
{
    Console.WriteLine($"The column is {column}");
}

U kunt één lus in de andere nesten om paren te vormen:

for (int row = 1; row < 11; row++)
{
    for (char column = 'a'; column < 'k'; column++)
    {
        Console.WriteLine($"The cell is ({row}, {column})");
    }
}

U kunt zien dat de buitenste lus eenmaal wordt verhoogd voor elke volledige uitvoering van de binnenste lus. Draai het nesten van rijen en kolommen om en bekijk de wijzigingen zelf. Wanneer u klaar bent, plaatst u de code uit deze sectie in een methode met de naam ExploreLoops().

Vertakkingen en lussen combineren

Nu u de instructie if en de lusconstructies in de computertaal C# hebt gezien, kijken we of u C#-code kunt schrijven om de som van de gehele getallen 1 tot en met 20 te vinden die deelbaar zijn door 3. Hier volgen een paar hints:

  • De %-operator biedt u het resterende deel van de divisiebewerking.
  • De instructie if biedt u de voorwaarde om te zien of een getal deel moet uitmaken van de som.
  • De lus for kan u helpen bij het herhalen van een reeks stappen voor alle getallen 1 tot en met 20.

Probeer het zelf eens. Controleer daarna wat u hebt gemaakt. U moet 63 krijgen voor een antwoord. U kunt één mogelijk antwoord zien door de voltooide code op GitHub te bekijken.

U hebt de zelfstudie 'vertakkingen en lussen' voltooid.

U kunt doorgaan met de zelfstudie Matrices en verzamelingen in uw eigen ontwikkelomgeving.

Meer informatie over deze concepten vindt u in deze artikelen: