C# if-instructies en -lussen: handleiding voor voorwaardelijke logica

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 waarin vertakkings- en lusconstructies in C# worden verkend. In deze lessen leert u de basisprincipes van de C#-taal.

Fooi

Wanneer een codefragmentblok de knop Uitvoeren bevat, wordt het interactieve venster geopend of wordt de bestaande code in het interactieve venster vervangen. Wanneer het codefragment geen knop Uitvoeren bevat, kunt u de code kopiëren en toevoegen aan het huidige interactieve venster.

Voer de volgende code uit in het interactieve venster. Selecteer , voeruit:

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

Wijzig de declaratie van b zodat de som kleiner is dan 10:

int b = 3;

Selecteer opnieuw de knop uitvoeren. Omdat het antwoord kleiner is dan 10, wordt er niets afgedrukt. De voorwaarde die u test is onwaar. U hebt geen code om uit te voeren omdat u slechts een van de mogelijke vertakkingen hebt geschreven voor een if-instructie: de true branch.

Tip

Terwijl u C# (of een programmeertaal) verkent, maakt u fouten wanneer u code schrijft. De compiler vindt deze fouten en rapporteert deze aan u. Wanneer de uitvoer foutberichten bevat, bekijkt u de voorbeeldcode en de code in het interactieve venster om te zien wat u moet oplossen. Deze oefening helpt u de structuur van C#-code te leren.

In dit eerste voorbeeld ziet u de kracht van if- en Booleaanse typen. Een booleaanse is een variabele die een van de volgende twee waarden kan hebben: true of false. C# definieert een speciaal type, bool voor Booleaanse variabelen. De instructie if controleert de waarde van een bool. Wanneer de waarde is true, wordt de instructie na de if uitgevoerd. Anders wordt het overgeslagen.

Dit proces voor het controleren van voorwaarden en het uitvoeren van instructies op basis van deze voorwaarden is krachtig. Laten we eens kijken.

Laat if en else samenwerken

Als u verschillende code in zowel de waar- als onwaar-vertakkingen wilt uitvoeren, maakt u een else vertakking die wordt uitgevoerd wanneer de voorwaarde onwaar is. Probeer 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");

De instructie na het trefwoord else wordt alleen uitgevoerd wanneer de voorwaarde die wordt getest falseis. Het combineren van if en else met booleaanse voorwaarden biedt alle mogelijkheden die u nodig hebt.

Belangrijk

De inspringing onder de if- en else-verklaringen is bedoeld voor menselijke lezers. De C#-taal behandelt inspringingen en witruimtes niet als van belang. De instructie na het if of else trefwoord wordt uitgevoerd op basis van de voorwaarde. Alle voorbeelden in deze zelfstudie volgen een veelvoorkomende procedure om regels te laten inspringen op basis van de controlestroom van instructies.

Omdat inspringing niet van belang is, moet u { en } gebruiken om aan te geven als u meer dan één instructie wilt opnemen in het blok dat onder voorwaarden wordt uitgevoerd. C#-programmeurs gebruiken die accolades meestal op alle if- en else-clausules. Het volgende voorbeeld is hetzelfde als wat u hebt gemaakt. Probeer het maar eens.

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 handleiding bevatten de codevoorbeelden allemaal accolades, volgens geaccepteerde praktijken.

U kunt complexere voorwaarden testen:

int a = 5;
int b = 3;
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 test voor gelijkheid onderscheiden van toewijzing, zoals u in a = 5hebt gezien.

De && vertegenwoordigt 'and'. Dit betekent dat beide voorwaarden waar moeten zijn om de instructie uit te voeren in de true branch. Deze voorbeelden laten ook zien dat u meerdere uitspraken in elke voorwaardelijke vertakking kunt hebben, mits u ze plaatst in { en }.

U kunt ook || gebruiken om 'or' weer te geven:

if ((a + b + c > 10) || (a == b))

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

Lussen gebruiken om bewerkingen te herhalen

Een ander belangrijk concept voor het maken van grotere programma's is lussen. U gebruikt lussen om instructies te herhalen die u meerdere keren wilt uitvoeren. Probeer deze code in het interactieve venster:

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 uit volgens de while. Het herhaalt het controleren van de voorwaarde en het uitvoeren van deze instructies totdat de voorwaarde onwaar is.

In dit voorbeeld is er nog een andere nieuwe operator. De ++ na de variabele counter is de operator incrementele. Hiermee wordt 1 toegevoegd aan de waarde van de teller en wordt die waarde opgeslagen in de tellervariabele.

Belangrijk

Zorg ervoor dat de while-lusvoorwaarde onwaar wordt wanneer u de code uitvoert. Anders maakt u een oneindige lus waar uw programma nooit eindigt. Laten we dat niet demonstreren omdat de engine die uw code uitvoert een time-out heeft, en u dus geen uitvoer van uw programma ziet.

De while lus test de voorwaarde voordat de code wordt uitgevoerd na de while. De do ... while lus voert eerst de code uit en controleert vervolgens de voorwaarde. Dit ziet er als volgt uit:

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

Deze do lus en de eerdere while lus werken hetzelfde.

We gaan verder met één laatste lusinstructie.

Werken met de for-lus

Een andere algemene lusinstructie die u in C#-code ziet, is de for lus. Probeer deze code in het interactieve venster:

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

De voorgaande for lus werkt hetzelfde als de while lus en de do lus die u al hebt gebruikt. De for-instructie bevat drie onderdelen die bepalen hoe deze werkt:

• Het eerste deel is de voor initialisatiefunctie: int counter = 0; declareert dat counter de lusvariabele is en stelt de oorspronkelijke waarde in op 0.
• Het middelste gedeelte is de voor voorwaarde: counter < 10 declareert dat deze for lus blijft worden uitgevoerd zolang de waarde van de teller kleiner is dan 10.
• Het laatste deel is de voor iterator-: counter++ geeft aan hoe de lusvariabele moet worden gewijzigd nadat het blok is uitgevoerd na de instructie for. Hier geeft het aan dat counter wordt verhoogd met 1 telkens wanneer het blok wordt uitgevoerd.

Experimenteer zelf met deze voorwaarden. Probeer elk van de volgende wijzigingen:

• Wijzig de initialisatiefunctie om te beginnen bij een andere waarde.
• Wijzig de voorwaarde om te stoppen bij een andere waarde.

Wanneer u klaar bent, gaan we verder met het schrijven van code zelf om te gebruiken wat u hebt geleerd.

Er is nog een andere lusinstructie die niet wordt behandeld in deze handleiding: de foreach-instructie. De instructie foreach herhaalt de instructie voor elk item in een reeks items. Het wordt meestal gebruikt met verzamelingen. Dit komt aan bod in de volgende tutorial.

Geneste lussen gemaakt

Een while, doof for lus kan in een andere lus worden genest 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.

Een 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}");
}

Je 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 de rij- en kolomnesten om en bekijk zelf de wijzigingen.

Vertakkingen en lussen combineren

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

• De operator % geeft u het resultaat van een delingsbewerking.
• De instructie if geeft u de voorwaarde om te zien of een getal deel moet uitmaken van de som.
• Met de for lus kunt u een reeks stappen herhalen voor alle getallen 1 tot en met 20.

Probeer het zelf. Controleer vervolgens hoe u dat hebt gedaan. Als hint zou het antwoord 63 moeten zijn.

Heb je zoiets bedacht?

:::code language="csharp" interactive="try-dotnet-method" source="./snippets/BranchesAndLoops/Program.cs" id="Challenge":::

U hebt de interactieve zelfstudie 'vertakkingen en lussen' voltooid. U kunt de lijstverzameling link selecteren om de volgende interactieve tutorial te starten, of u kunt de .NET-site bezoeken om de .NET SDK te downloaden, een project op uw computer te maken en door te gaan met coderen. In de sectie "Volgende stappen" verwijst u terug naar deze tutorials.

Meer informatie over deze concepten vindt u in deze artikelen:

• selectie-uitspraken
• iteratieverklaringen