Zie Scherp Scherper
OefeningenThe Corona filesHandboek backup
  • H0: Introductie
    • Introductie
    • Dit boek in papier?
    • Nuttige extras
  • H1: De eerste stappen
    • Introductie tot C#
    • Werken met Visual Studio
    • Je eerste programma
    • Input verwerken met ReadLine
    • Fouten in je code
    • Kleuren in Console
    • Meer weten
  • H2: De basisconcepten van C#
    • De essentie van C#
    • Datatypes
    • Variabelen
    • Expressies en operators
    • Const(ant)
    • Solutions en projecten
    • Meer weten
  • H3: Tekst gebruiken in code
    • Strings en chars
    • Escape characters
    • Strings samenvoegen
    • Unicode tonen
    • Environment bibliotheek
    • Meer weten
  • H4: Werken met data
    • Casting, conversie en parsing
    • Input verwerken en omzetten
    • Math-library en berekeningen
    • Over afronden
    • Random
    • Debuggen
    • Meer weten
  • H5: Beslissingen
    • Beslissingen intro
    • Booleanse logica en operators
    • If
    • Scope van variabelen
    • Switch
    • enum
    • Meer weten
  • H6: Herhalingen Herhalingen Herhalingen
    • Loops intro
    • While en Do While
    • For
    • Nesting
    • Meer weten
  • H7: Methoden
    • Methoden intro
    • Bibliotheken
    • Geavanceerde methodetechnieken
    • Meer weten
  • H8: Arrays
    • Array principes
    • Arrays en geheugen
    • System.Array
    • Algoritmes met arrays
    • Strings en arrays
    • Arrays en methoden
    • N-dimensionale arrays
    • Jagged arrays
    • Meer weten
  • H9: Object Oriented Programming
    • OOP Intro
    • Klassen en objecten in C#
    • Methoden en access modifiers
    • Full properties
    • Auto-properties
    • DateTime: leren werken met objecten
    • Meer weten
  • H10: Geheugenmanagement, uitzonderingen en namespaces
    • Stack en Heap
    • Objecten en methoden
    • Null en NullReferenceException
    • Namespaces en using
    • Exception handling
    • Waar exceptions plaatsen?
    • Meer weten
  • H11: Gevorderde klasseconcepten
    • Constructors en de default Constructors
    • Overloaded Constructors
    • Object Initializer Syntax
    • Static
    • Meer weten
  • H12: Arrays en klassen
    • Arrays van objecten
    • List
    • Foreach en var
    • Nuttige collection klassen
    • Meer weten
  • H13: Overerving
    • Overerving intro
    • Constructors bij overerving
    • Virtual en override
    • Base keyword
    • Meer weten
  • H14: Gevorderde overervingsconcepten
    • System.Object
    • Abstract
    • Eigen exceptions maken
    • Kennisclips
  • H15: Compositie en aggregatie
    • Compositie
    • this keyword
    • Meer weten
  • H16: Polymorfisme
    • Polymorfisme
    • Polymorfisme in de praktijk
    • Is en As keywords
    • Objecten vergelijken: alles komt samen
    • Meer weten
  • H17: Interfaces
    • Interface intro
    • Interfaces voorbeeld met president
    • Interfaces in de praktijk
    • Interfaces en polymorfisme
    • Meer weten
  • H18: Bestandsverwerking
    • Werken met bestanden
    • Schrijven en lezen
    • FileInfo klasse
    • Klassen serialiseren met json
    • Meer weten
  • Conclusie
    • Je hebt het gehaald
    • En nu?
  • Kennicslips
    • H1 - H8
    • H9 - H17
  • Appendix
    • Visual Studio snippets
    • VS Code for Mac installeren
    • Regions
    • String.Format
    • Out en Ref parameters
    • Operator overloading
    • Expression bodied members
    • Generics
    • struct en record
    • Een installer maken
  • Coding guidelines
    • Afspraken
    • Minpunten voor: Compileert niet
    • Minpunten voor: Klassen in 1 bestand
    • Minpunten voor: Redundante code
    • Minpunten voor: Bladspiegel
    • Minpunten voor: Naamgeving
    • Minpunten voor: goto, break en continue
    • Minpunten voor: Linq gebruiken
    • Minpunten voor: Methoden in methoden
    • Minpunten voor: Toplevel statements
Powered by GitBook
On this page
  • Booleaanse expressies
  • Relationele operators
  • Logische operators
  • Niet-operator
  • Volgorde van bewerkingen
  • Test jezelf

Was this helpful?

  1. H5: Beslissingen

Booleanse logica en operators

Om beslissingen te kunnen nemen in C# hebben we een nieuw soort operators nodig. Operators waarmee we kunnen testen of iets waar of niet waar is. Met C# kun je een actie uitvoeren als een voorwaarde waar is, en iets anders doen (of een stap overslaan) als de voorwaarde niet waar is.

Dit doen we met de zogenaamde relationele operators en logische operators.

Booleaanse expressies

Een booleaanse expressie is een stuk C# code dat een bool als resultaat zal geven. De logische en relationele operators die ik hierna bespreek zijn operators die een bool teruggeven. Ze zijn zogenaamde test-operators: ze testen of iets waar is of niet.

Relationele operators

Relationele operators zijn het hart van booleaanse expressies. En guess what, je kent die al van uit het lager onderwijs. Enkel de "gelijk aan" ziet er iets anders uit dan we gewoon zijn uit onze lessen wiskunde:

Operator
Betekenis

>

groter dan

<

kleiner dan

==

gelijk aan

!=

niet gelijk aan

<=

kleiner dan of gelijk aan

>=

groter dan of gelijk aan

Deze operators hebben steeds twee operanden nodig en geven een bool als resultaat terug. Beide operanden moeten van hetzelfde datatype zijn. Je kan geen appelen met peren vergelijken!

Daar dit operators zijn kan je deze dus gebruiken in eender welke expressie. Het resultaat van de expressie 12 > 6 zal true als resultaat hebben daar 12 groter is dan 6. Eenvoudig toch.

We weten al dat je het resultaat van een expressie altijd in een variabele kunt bewaren. Ook bij het gebruik van relationele operators kan dat dus:

bool isKleiner = 65 > 67 ;
Console.WriteLine(isKleiner);

Er zal false als output op het scherm verschijnen.

Er is een groot verschil tussen de = operator en de == operator. De eerste is de toekenningsoperator en zal de rechtse operand aan de linkse operand toewijzen. De tweede zal de linkse met de rechtse operand op gelijkheid vergelijken en een bool teruggeven.

Logische operators

Vaak wil je meer complexe keuzes maken, zoals :"ga verder indien je hongerig bent EN je genoeg geld bijhebt". Dit doen we met de zogenaamde logische operators.

Er zijn 3 (booleaanse) operators die je hiervoor kunt gebruiken:

  • && (EN) : Geeft enkel true als beide operanden true zijn

  • || (OF) : Geeft true indien minstens 1 operand true is

  • ! (NIET) : Inverteert de waarde van de expressie (true wordt false en omgekeerd)

De logische operators geven ook steeds een bool terug maar verwachten enkel operanden van het type bool. Als je dus schrijft true || false zal het resultaat true zijn.

De EN en OF operators verwachten 2 operanden. Maar de NIET-operator verwacht maar 1 operand.

Aangezien onze relationele operators bool als resultaat geven, kunnen we dus de uitvoer van deze operators gebruiken als operanden voor de logische operators. We gebruiken hierbij haakjes om zeker de volgorde juist te krijgen:

bool result = (4 < 6) && ("ja" == "nee");

De haakjes zorgen ervoor dat eerste die delen worden berekend. Voorgaande zal dus in een tussenstap (die jij niet ziet) tijdens de uitvoer er als volgt uitzien:

bool result = true && false;

Vervolgens wordt dan de logische EN getest en krijgen we finaal false in result.

Niet-operator

Je kan de niet-operator voor een expressie zetten om het resultaat van de expressie te inverteren. Bijvoorbeeld:

bool result = !(0==2) 

Eerst wordt weer het resultaat tussen de haakjes berekend. Dit geeft false (daar 0 niet gelijk is aan 2). Vervolgens passen we de NIET-operator toe op dit resultaat en zal er dus true bewaard worden.

Merk op dat we deze code ook kunnen schrijven als:

bool result = (0!=2) 

Alhoewel we voorgaande ook zonder haakjes kunnen schrijven, raad ik dit af. Haakjes zorgen ervoor dat je code leesbaarder wordt. Maar nog belangrijker: het maakt de volgorde van bewerkingen explicieter. Als je niet zeker weet welke operator voorrang heeft, kun je haakjes gebruiken om de juiste volgorde af te dwingen. Dit helpt je om logische fouten te voorkomen die kunnen ontstaan door verkeerde veronderstellingen.

Volgorde van bewerkingen

De volgorde van bewerkingen wordt nu ! In C# hebben de operatoren die we al kennen volgende volgorde:

  1. Logische NIET: !

  2. Delen en vermenigvuldigen: *, /, %

  3. Optellen en aftrekken: +, -

  4. Relationele operators: <, <=, >, >=

  5. Gelijkheid: ==, !=

  6. Logische EN: &&

  7. Logische OF: ||

Wil je deze volgorde dus veranderen in een samengestelde expressie, dan moet je gebruik maken van haakjes.

Test jezelf

Wat zal de uitkomst zijn van volgende expressies?

  • 3>2

  • 4!=4

  • 4<5 && 4<3

  • "a"=="A" || 4>=3

  • (3==3 && 2<1) || 5!=4

  • !(4<=3)

  • true || false

  • !true && false

PreviousBeslissingen introNextIf

Last updated 11 months ago

Was this helpful?