Programmeren

10.3 - Testing

Sat, 21 Jun 2025 16:20:16 GMT

Testen is een cruciaal onderdeel van softwareontwikkeling dat helpt ontwikkelaars om fouten en bugs in de software te identificeren en op te lossen vóór release.✅ Waarom is testen essentieel? Zorgt voor softwarekwaliteit en betrouwbaarheid. Helpt bugs en prestatieproblemen vroegtijdig te detecteren. Verhoogt gebruikerservaring en voldoet aan vereisten. ✅ Test individuele componenten van de software.[Test] public void Add_AddsTwoNumbers_ReturnsSum() { int result = calculator.Add(2, 3); Assert.AreEqual(5, result); } ✅ Hier wordt gecontroleerd of de methode Add correct werkt.✅ Test samenwerking tussen verschillende softwarecomponenten.[Test] public void GetUser_ReturnsValidData() { var user = api.GetUser(1); Assert.IsNotNull(user); Assert.AreEqual("John Doe", user.Name); } ✅ Hier wordt getest of de API correct gegevens uit de database ophaalt.✅ Test het volledige systeem als een geheel.✅ Verifiëren of de software voldoet aan gebruikersvereisten.✅ Testen of recente wijzigingen geen bestaande functionaliteit breken.[Test] public void BugFix_DoesNotBreakExistingFeature() { bool result = application.ProcessData("test input"); Assert.IsTrue(result); } ✅ Hier wordt getest of een bugfix geen nieuwe problemen veroorzaakt.✅ Testen van snelheid, schaalbaarheid en stabiliteit onder verschillende omstandigheden.✅ Evalueren van beveiliging en bescherming tegen aanvallen.✅ Testen van gebruiksvriendelijkheid door echte gebruikers.✅ Testen verhoogt softwarekwaliteit en betrouwbaarheid. ✅ Unit en integration tests controleren basisfunctionaliteit en samenwerking. ✅ Security en usability tests zorgen voor veilige en gebruiksvriendelijke software.✅ Een Unit Test project aanmaken in JetBrains Rider om methoden uit het hoofdproject te testen.Rider ondersteunt unit testing met NUnit, xUnit en MSTest. We gebruiken NUnit, omdat het breed ondersteund wordt en goed integreert met Rider. Open Rider en je hoofdproject. Ga naar File > New > Project. Selecteer .NET Core > NUnit Test Project. Kies een relevante naam, zoals Projectnaam.Tests. Klik op Create om het testproject toe te voegen aan dezelfde solution als het hoofdproject. ✅ Je hebt nu een Unit Test project in je solution. Open de Projectnaam.Tests solution. Ga naar File > Add Reference. Selecteer het hoofdproject (Projectnaam). Klik op OK om de referentie toe te voegen. ✅ Je testproject kan nu methoden uit het hoofdproject aanroepen. Maak een nieuwe testklasse aan in Projectnaam.Tests. Gebruik NUnit om een testmethode te schrijven. using NUnit.Framework; using Projectnaam; [TestFixture] public class CalculatorTests { private Calculator calculator; [SetUp] public void SetUp() { calculator = new Calculator(); } [Test] public void Add_AddsTwoNumbers_ReturnsSum() { int result = calculator.Add(2, 3); Assert.AreEqual(5, result); } } ✅ Hier testen we of Add(2, 3) correct 5 retourneert. ✅ De methode SetUp() installeert een nieuwe Calculator-instantie voor elke test. Open het Unit Tests venster via View > Tool Windows > Unit Tests. Klik op Run All om alle tests uit te voeren. Controleer of alle tests slagen of falen. ✅ Als de test groen is, werkt de methode correct. ✅ Als een test faalt, pas de code aan en voer de test opnieuw uit.Meer uitleg over testuitvoering in Rider vind je op JetBrains Rider Docs.

10.2 - Debugging

Sat, 21 Jun 2025 16:17:33 GMT

Debugging is het proces van het identificeren, analyseren en oplossen van fouten of bugs in software.✅ Waarom is debugging essentieel? Verhoogt de softwarekwaliteit door fouten te corrigeren vóór release. Voorkomt crashes en onverwacht gedrag in een applicatie. ✅ Handmatig fouten opsporen door de code te analyseren.✅ Voeg Console.WriteLine() statements toe om variabelen en uitvoer te controleren.for (int i = 0; i < numbers.Length; i++) { Console.WriteLine("i: " + i + ", numbers[i]: " + numbers[i]); } ✅ Hier controleren we de iteratievariabele en de lijstwaarden tijdens de loop.✅ Gebruik een debugger om breakpoints te zetten en variabelen te inspecteren.✅ Debug een programma dat op een andere machine draait. Gebruik Remote Debugging in Visual Studio om een applicatie op een productieomgeving te debuggen. Verbind via SSH of netwerk om logbestanden te analyseren. ✅ Analyseer de staat van een programma na een crash.✅ Gebruik tools om bugs automatisch te detecteren en op te lossen.✅ Debugging is essentieel voor foutopsporing en softwarekwaliteit. ✅ Gebruik print, interactive, remote en post-mortem debugging afhankelijk van de situatie. ✅ Automated debugging versnelt foutdetectie en verbetert efficiëntie.

9.10 - COUNT en EXISTS

Sat, 21 Jun 2025 13:37:36 GMT

In deze paragraaf leren we hoe we records kunnen tellen met COUNT en controleren of een record bestaat met EXISTS.✅ Waarom COUNT en EXISTS gebruiken? COUNT → Telt het aantal records dat voldoet aan een bepaalde voorwaarde. EXISTS → Controleert of een record bestaat zonder het volledige aantal op te vragen. ✅ Gebruik COUNT(*) om het aantal records in een tabel te tellen.using System; using Microsoft.Data.SqlClient; public static class DbConnection { private static string connectionString = "Server=(localdb)\\MyInstance;Database=opdrachten;Integrated Security=true;"; public static int GetStudentCount() { int count = 0; using (SqlConnection connection = new SqlConnection(connectionString)) { string countQuery = "SELECT COUNT(*) FROM dbo.Studenten"; using (SqlCommand command = new SqlCommand(countQuery, connection)) { connection.Open(); count = (int)command.ExecuteScalar(); } } return count; } } ✅ Hier wordt het totale aantal studenten in de Studenten-tabel geteld. ✅ De methode ExecuteScalar() retourneert een enkele waarde (het aantal records).✅ Gebruik EXISTS om te controleren of een record bestaat zonder het volledige aantal op te vragen.public static bool StudentExists(int studentnummer) { bool exists = false; using (SqlConnection connection = new SqlConnection(connectionString)) { string existsQuery = @" SELECT CASE WHEN EXISTS (SELECT 1 FROM dbo.Studenten WHERE Studentnummer = @Studentnummer) THEN 1 ELSE 0 END"; using (SqlCommand command = new SqlCommand(existsQuery, connection)) { command.Parameters.Add("@Studentnummer", SqlDbType.Int).Value = studentnummer; connection.Open(); exists = (int)command.ExecuteScalar() == 1; } } return exists; } ✅ Hier wordt gecontroleerd of een student met een bepaald Studentnummer bestaat. ✅ De query retourneert 1 als de student bestaat en 0 als dat niet het geval is.✅ Gebruik COUNT als: Je het exacte aantal records wilt weten. Je statistieken of rapportages wilt genereren. ✅ Gebruik EXISTS als: Je alleen wilt controleren of een record bestaat. Je de database wilt optimaliseren door geen onnodige tellingen uit te voeren. ✅ Gebruik COUNT(*) om het aantal records in een tabel te tellen. ✅ Gebruik EXISTS om te controleren of een record bestaat zonder het volledige aantal op te vragen. ✅ Gebruik ExecuteScalar() om een enkele waarde uit een query op te halen. ✅ Optimaliseer je database-interacties door COUNT en EXISTS correct toe te passen.

9.9 - DELETE

Sat, 21 Jun 2025 13:36:12 GMT

In deze paragraaf leren we hoe we gegevens kunnen verwijderen uit een tabel met behulp van een DELETE-statement.✅ Waarom gegevens verwijderen met DELETE? Verwijder records die niet langer nodig zijn. Houd de database schoon en efficiënt. Gebruik DELETE met prepared statements om SQL-injectie te voorkomen. ✅ Gebruik een helper klasse en prepared statements om veilig gegevens te verwijderen.using System; using Microsoft.Data.SqlClient; public static class DbConnection { private static string connectionString = "Server=(localdb)\\MyInstance;Database=opdrachten;Integrated Security=true;"; public static void DeleteStudent(int studentnummer) { using (SqlConnection connection = new SqlConnection(connectionString)) { string deleteQuery = "DELETE FROM dbo.Studenten WHERE Studentnummer = @Studentnummer"; using (SqlCommand command = new SqlCommand(deleteQuery, connection)) { command.Parameters.Add("@Studentnummer", SqlDbType.Int).Value = studentnummer; connection.Open(); int rowsAffected = command.ExecuteNonQuery(); Console.WriteLine($"{rowsAffected} row(s) deleted successfully."); } } } } ✅ Hier wordt een specifieke student uit de Studenten-tabel verwijderd. ✅ Prepared statements voorkomen SQL-injectie en zorgen voor veilige database-operaties.✅ Roep de delete-methode aan vanuit de Program klasse.class Program { static void Main(string[] args) { int studentnummer = 8; // Het studentnummer van de student die we willen verwijderen DbConnection.DeleteStudent(studentnummer); Console.WriteLine("Student deleted successfully."); } } ✅ Hier wordt een student met studentnummer 8 verwijderd. ✅ De delete-methode wordt direct aangeroepen om de wijziging door te voeren.✅ Gebruik DELETE als: Je oude of onnodige gegevens uit een tabel wilt verwijderen. Je een specifieke record wilt verwijderen op basis van een unieke identificatie (zoals een ID). Je de database schoon en overzichtelijk wilt houden. ✅ Gebruik DELETE om een specifieke rij in de database te verwijderen. ✅ Prepared statements voorkomen SQL-injectie en zorgen voor veilige database-operaties. ✅ Roep de DeleteStudent methode aan met het studentnummer om een record te verwijderen. ✅ Controleer altijd of de query correct is en geen fouten veroorzaakt.

9.8 - UPDATE

Sat, 21 Jun 2025 13:35:24 GMT

In deze paragraaf leren we hoe we gegevens kunnen wijzigen in een tabel met behulp van een UPDATE-statement.✅ Waarom gegevens bijwerken met UPDATE? Corrigeer fouten in bestaande records. Pas gegevens aan op basis van nieuwe informatie. Update een specifieke rij zonder een volledige tabel te overschrijven. ✅ Gebruik een helper klasse en prepared statements om veilig gegevens bij te werken.using System; using Microsoft.Data.SqlClient; public static class DbConnection { private static string connectionString = "Server=(localdb)\\MyInstance;Database=opdrachten;Integrated Security=true;"; public static void UpdateStudent(int studentnummer, string nieuweVoornaam, string nieuweAchternaam, int nieuweLeeftijd) { using (SqlConnection connection = new SqlConnection(connectionString)) { string updateQuery = @" UPDATE dbo.Studenten SET Voornaam = @NieuweVoornaam, Achternaam = @NieuweAchternaam, Leeftijd = @NieuweLeeftijd WHERE Studentnummer = @Studentnummer"; using (SqlCommand command = new SqlCommand(updateQuery, connection)) { command.Parameters.Add("@NieuweVoornaam", SqlDbType.NVarChar, 100).Value = nieuweVoornaam; command.Parameters.Add("@NieuweAchternaam", SqlDbType.NVarChar, 100).Value = nieuweAchternaam; command.Parameters.Add("@NieuweLeeftijd", SqlDbType.Int).Value = nieuweLeeftijd; command.Parameters.Add("@Studentnummer", SqlDbType.Int).Value = studentnummer; connection.Open(); int rowsAffected = command.ExecuteNonQuery(); Console.WriteLine($"{rowsAffected} row(s) updated successfully."); } } } } ✅ Hier wordt de voornaam, achternaam en leeftijd van een specifieke student bijgewerkt. ✅ Prepared statements zorgen ervoor dat SQL-injectie wordt voorkomen.✅ Roep de update-methode aan vanuit de Program klasse.class Program { static void Main(string[] args) { int studentnummer = 8; // Het studentnummer van de student die we willen bijwerken string nieuweVoornaam = "Jan"; string nieuweAchternaam = "Jansen"; int nieuweLeeftijd = 20; DbConnection.UpdateStudent(studentnummer, nieuweVoornaam, nieuweAchternaam, nieuweLeeftijd); Console.WriteLine("Student updated successfully."); } } ✅ Hier wordt een student met studentnummer 8 bijgewerkt. ✅ De update-methode wordt direct aangeroepen om wijzigingen toe te passen.✅ Gebruik UPDATE als: Je bestaande gegevens wilt wijzigen zonder een nieuwe rij toe te voegen. Je een specifieke record wilt aanpassen, bijvoorbeeld een naam of een status. Je een fout in de database wilt corrigeren. ✅ Gebruik UPDATE om een specifieke rij in de database bij te werken. ✅ Prepared statements voorkomen SQL-injectie en zorgen voor veilige database-operaties. ✅ Roep de UpdateStudent methode aan met de nieuwe gegevens om een wijziging door te voeren. ✅ Controleer altijd of de query correct is en geen fouten veroorzaakt.

9.7 - READ

Sat, 21 Jun 2025 13:33:36 GMT

In deze paragraaf leren we hoe we gegevens uit een tabel kunnen opvragen en verwerken binnen onze applicatie.✅ Wat kunnen we doen met de opgehaalde gegevens? De data in de console tonen. De gegevens verwerken in een grafische user interface (GUI). Objecten maken van elke rij en deze in een lijst plaatsen. ✅ Gebruik een helper klasse om alle gegevens uit een tabel op te vragen.using System; using Microsoft.Data.SqlClient; public static class DbConnection { private static string connectionString = "Server=(localdb)\\MyInstance;Database=opdrachten;Integrated Security=true;"; public static void SelectAllFromTable(string tableName) { using (SqlConnection connection = new SqlConnection(connectionString)) { string selectQuery = $"SELECT * FROM {tableName}"; using (SqlCommand command = new SqlCommand(selectQuery, connection)) { connection.Open(); using (SqlDataReader reader = command.ExecuteReader()) { while (reader.Read()) { for (int i = 0; i < reader.FieldCount; i++) { Console.Write($"{reader.GetName(i)}: {reader[i]} "); } Console.WriteLine(); } } } } } } class Program { static void Main(string[] args) { DbConnection.SelectAllFromTable("Leerlingen"); Console.WriteLine("Data retrieved successfully."); } } ✅ Hier wordt alle data uit de tabel Leerlingen opgehaald en in de console geprint. ✅ De SqlDataReader leest rijen uit de database en toont ze op het scherm.✅ Gegevens ophalen als objecten in plaats van losse waarden.public class Student { public int Studentnummer { get; set; } public string Voornaam { get; set; } public string Achternaam { get; set; } public int Leeftijd { get; set; } } ✅ De DbConnection klasse met een methode om studenten op te halenusing System; using System.Collections.Generic; using Microsoft.Data.SqlClient; public static class DbConnection { private static string connectionString = "Server=(localdb)\\MyInstance;Database=opdrachten;Integrated Security=true;"; public static List GetAllStudents() { var students = new List(); using (SqlConnection connection = new SqlConnection(connectionString)) { string selectQuery = "SELECT Studentnummer, Voornaam, Achternaam, Leeftijd FROM dbo.Studenten"; using (SqlCommand command = new SqlCommand(selectQuery, connection)) { connection.Open(); using (SqlDataReader reader = command.ExecuteReader()) { while (reader.Read()) { var student = new Student { Studentnummer = reader.GetInt32(reader.GetOrdinal("Studentnummer")), Voornaam = reader.GetString(reader.GetOrdinal("Voornaam")), Achternaam = reader.GetString(reader.GetOrdinal("Achternaam")), Leeftijd = reader.GetInt32(reader.GetOrdinal("Leeftijd")) }; students.Add(student); } } } } return students; } } ✅ De Program klasse om studenten op te halenclass Program { static void Main(string[] args) { List students = DbConnection.GetAllStudents(); foreach (var student in students) { Console.WriteLine($"Studentnummer: {student.Studentnummer}, Voornaam: {student.Voornaam}, Achternaam: {student.Achternaam}, Leeftijd: {student.Leeftijd}"); } Console.WriteLine("Data retrieved and converted to Student objects successfully."); } } ✅ Hier wordt elke rij uit de Studenten-tabel omgezet naar een Student object. ✅ De gegevens worden opgeslagen in een List voor verdere verwerking.✅ Gebruik een WHERE-clausule om een specifieke student op te halen.public static class DbConnection { private static string connectionString = "Server=(localdb)\\MyInstance;Database=opdrachten;Integrated Security=true;"; public static Student GetStudentByNumber(int studentnummer) { Student student = null; using (SqlConnection connection = new SqlConnection(connectionString)) { string selectQuery = "SELECT Studentnummer, Voornaam, Achternaam, Leeftijd FROM dbo.Studenten WHERE Studentnummer = @Studentnummer"; using (SqlCommand command = new SqlCommand(selectQuery, connection)) { command.Parameters.Add("@Studentnummer", SqlDbType.Int).Value = studentnummer; connection.Open(); using (SqlDataReader reader = command.ExecuteReader()) { if (reader.Read()) { student = new Student { Studentnummer = reader.GetInt32(reader.GetOrdinal("Studentnummer")), Voornaam = reader.GetString(reader.GetOrdinal("Voornaam")), Achternaam = reader.GetString(reader.GetOrdinal("Achternaam")), Leeftijd = reader.GetInt32(reader.GetOrdinal("Leeftijd")) }; } } } } return student; } } ✅ De Program klasse om een specifieke student op te vragenclass Program { static void Main(string[] args) { Student student = DbConnection.GetStudentByNumber(8); if (student != null) { Console.WriteLine($"Student gevonden: {student.Voornaam} {student.Achternaam}, Leeftijd: {student.Leeftijd}"); } else { Console.WriteLine("Student niet gevonden."); } } } ✅ Hier wordt een specifieke student gezocht via het Studentnummer. ✅ Indien een student wordt gevonden, wordt hij weergegeven in de console.✅ Gebruik SELECT * om alle gegevens uit een tabel op te halen. ✅ Gebruik een helper klasse om gegevens op te halen als objecten in plaats van ruwe data. ✅ Gebruik een WHERE-clausule om specifieke gegevens op te vragen. ✅ Sla opgehaalde gegevens op in een lijst (List) voor verdere verwerking.

9.5 - INSERT INTO

Sat, 21 Jun 2025 13:30:30 GMT

Het toevoegen van gegevens aan een tabel is eenvoudig wanneer je werkt met een helper klasse zoals DbConnection.✅ BELANGRIJK: In deze paragraaf maken we nog geen gebruik van prepared statements. Zonder prepared statements kunnen snelle methoden worden geschreven, maar dit brengt het risico van SQL Injection met zich mee. Meer over beveiliging en prepared statements in de volgende paragraaf 9.6 - Prepared statements! ✅ Gebruik INSERT INTO om één rij toe te voegen aan een tabel.using System; using Microsoft.Data.SqlClient; class Program { static void Main(string[] args) { string insertRowStatement = @" INSERT INTO Students (StudentID, FirstName, LastName, EnrollmentDate) VALUES (1, 'John', 'Doe', '2023-09-01')"; DbConnection.ExecuteCMD(insertRowStatement); Console.WriteLine("Row inserted successfully."); } } ✅ Hier voegen we één student toe aan de Students-tabel. ✅ De methode ExecuteCMD uit de helper klasse voert de INSERT INTO-query uit.✅ Je kunt meerdere rijen tegelijk invoeren met SQL Server.using System; using Microsoft.Data.SqlClient; class Program { static void Main(string[] args) { string insertMultipleRowsStatement = @" INSERT INTO Students (StudentID, FirstName, LastName, EnrollmentDate) VALUES (2, 'Jane', 'Smith', '2023-09-02'); INSERT INTO Students (StudentID, FirstName, LastName, EnrollmentDate) VALUES (3, 'Mike', 'Johnson', '2023-09-03'); INSERT INTO Students (StudentID, FirstName, LastName, EnrollmentDate) VALUES (4, 'Emily', 'Davis', '2023-09-04')"; DbConnection.ExecuteCMD(insertMultipleRowsStatement); Console.WriteLine("Multiple rows inserted successfully."); } } ✅ Hier voegen we drie studenten toe in één query. ✅ De SQL-statements worden gescheiden door puntkomma's.✅ Je kunt een loop gebruiken om meerdere rijen dynamisch in te voegen.using System; using System.Collections.Generic; using Microsoft.Data.SqlClient; class Program { static void Main(string[] args) { var students = new List<(int, string, string, DateTime)> { (5, "Alice", "Brown", new DateTime(2023, 9, 5)), (6, "Bob", "White", new DateTime(2023, 9, 6)), (7, "Charlie", "Green", new DateTime(2023, 9, 7)) }; foreach (var student in students) { string insertRowStatement = $@" INSERT INTO Students (StudentID, FirstName, LastName, EnrollmentDate) VALUES ({student.Item1}, '{student.Item2}', '{student.Item3}', '{student.Item4:yyyy-MM-dd}')"; DbConnection.ExecuteCMD(insertRowStatement); } Console.WriteLine("Multiple rows inserted successfully."); } } ✅ Hier gebruiken we een foreach-loop om dynamisch studenten toe te voegen. ✅ De waarden worden gegenereerd en via een SQL-query toegevoegd.❗ Beperkingen zonder prepared statements: Gevoelig voor SQL Injection-aanvallen. Hardcoded waarden kunnen foutgevoelig zijn. Moeilijk uitbreidbaar voor dynamische invoer van gebruikers. ✅ In de volgende paragraaf behandelen we prepared statements om deze problemen te voorkomen!✅ Gebruik INSERT INTO om gegevens toe te voegen aan een tabel in MS SQL Server. ✅ Je kunt meerdere rijen tegelijk invoegen met meerdere INSERT INTO-statements. ✅ Een foreach-loop maakt het dynamisch invoeren van data eenvoudiger. ✅ Zonder prepared statements kan je code kwetsbaar zijn voor SQL Injection.

9.6 - Prepared statements

Sat, 21 Jun 2025 13:29:14 GMT

Een prepared statement is een manier om SQL-queries veilig uit te voeren door de query en de invoergegevens te scheiden.✅ Voordelen van prepared statements: Veiligheid → Voorkomt SQL-injectie-aanvallen. Efficiëntie → De query wordt vooraf gecompileerd, wat prestaties verbetert bij herhaald gebruik. Leesbaarheid → Code wordt overzichtelijker en onderhoudbaarder. ✅ SQL-injectie is een aanval waarbij een hacker schadelijke SQL-code invoert via gebruikersinvoer.string query = "SELECT * FROM Users WHERE Username = '" + username + "' AND Password = '" + password + "'"; ✅ Als een aanvaller de volgende invoer gebruikt: Username: admin' -- Password: anything dan wordt resulterende SQL-query:SELECT * FROM Users WHERE Username = 'admin' --' AND Password = 'anything' ✅ Hierdoor kan de aanvaller zich aanmelden als 'admin' zonder een wachtwoord te kennen! Het deel voor het wachtwoord wordt namelijk als commentaar beschouwd, en zo krijgt de aanvaller toegang.✅ Prepared statements scheiden de query en de invoergegevens, waardoor schadelijke invoer geen invloed heeft op de querystructuur.using (SqlConnection connection = new SqlConnection(connectionString)) { string query = "SELECT * FROM Users WHERE Username = @Username AND Password = @Password"; using (SqlCommand command = new SqlCommand(query, connection)) { command.Parameters.Add("@Username", SqlDbType.NVarChar, 50).Value = username; command.Parameters.Add("@Password", SqlDbType.NVarChar, 50).Value = password; connection.Open(); using (SqlDataReader reader = command.ExecuteReader()) { // Verwerk de resultaten } } } ✅ Hier worden de parameters expliciet gedefinieerd met naam, datatype en lengte.💡 Waarom geen AddWithValue na command.Parameters., zoals in het verleden meestal werd gedaan? > AddWithValue() leidt soms tot prestatiedalingen of foutieve uitvoeringsplannen, omdat het datatype automatisch wordt afgeleid uit de C#-waarde. Oftewel: de database zal proberen om het gewenste datatype automatisch af te leiden van de C#-variabele. Dat komt niet altijd overeen met het verwachte SQL Server-datatype. Door het type expliciet te specificeren, voorkom je onnodige typecasts of cache-missers..✅ Gebruik prepared statements om veilig gegevens in te voegen in een database.public static void ExecutePreparedInsert(Leerling leerling) { using (SqlConnection connection = new SqlConnection(connectionString)) { string insertQuery = @" INSERT INTO dbo.Leerlingen (Leeftijd, Naam, Klas) VALUES (@Leeftijd, @Naam, @Klas)"; using (SqlCommand command = new SqlCommand(insertQuery, connection)) { command.Parameters.Add("@Leeftijd", SqlDbType.Int).Value = leerling.Leeftijd; command.Parameters.Add("@Naam", SqlDbType.NVarChar, 100).Value = leerling.Naam; command.Parameters.Add("@Klas", SqlDbType.NVarChar, 10).Value = leerling.Klas; connection.Open(); command.ExecuteNonQuery(); } } } ✅ Hier worden de invoerwaarden als parameters behandeld, waardoor SQL-injectie wordt voorkomen. Let wel goed op dat je achter het datatype de juiste hoeveelheid meegeeft! In bovenstaand voorbeeld gaan we bijvoorbeeld in de kolom Naam een waarde invoeren. We geven hierbij mee dat het om een NVarChar datatype gaat in de database en dat daar plaats is voor 100 tekens.✅ Prepared statements scheiden de SQL-query en de invoergegevens, waardoor SQL-injectie wordt voorkomen. ✅ Gebruik Parameters.Add met expliciet datatype voor maximale veiligheid én performance. ✅ Vermijd AddWithValue() om typeproblemen en prestatieproblemen te voorkomen. ✅ Prepared statements verbeteren de leesbaarheid, beveiliging en prestaties van je databasecode.

9.3 - Helper klasse

Sat, 21 Jun 2025 13:12:19 GMT

In de vorige paragraaf hebben we geleerd hoe we een connectie met een MS SQL Server database kunnen maken.✅ Waarom een helper class gebruiken? Maakt database-interacties efficiënter en herbruikbaar. Vermijdt herhaling van code bij veelvuldige databaseconnecties. Centraliseert de connection string en CRUD-methoden. ✅ Maak een nieuwe klasse aan en geef deze een relevante naam, bijvoorbeeld DbConnection, DbHelper, etc.using System; using Microsoft.Data.SqlClient; public class DbConnection { private string connectionString = "Server=(localdb)\\MyInstance;Database=MyDatabase;Integrated Security=true;"; public void ExecuteCMD(string statement) { using (SqlConnection connection = new SqlConnection(connectionString)) { SqlCommand command = new SqlCommand(statement, connection); command.Connection.Open(); command.ExecuteNonQuery(); } } public void SelectQuery(string query) { using (SqlConnection connection = new SqlConnection(connectionString)) { SqlCommand command = new SqlCommand(query, connection); command.Connection.Open(); SqlDataReader reader = command.ExecuteReader(); while (reader.Read()) { Console.WriteLine(reader.GetString(0)); } } } } ✅ Hier centraliseren we de connection string en CRUD-methoden in één klasse. ✅ De using-statement zorgt ervoor dat de connectie automatisch wordt gesloten na uitvoering.✅ Een static helper class maakt het mogelijk om methoden aan te roepen zonder een object te instantiëren.using System; using Microsoft.Data.SqlClient; public static class DbConnection { private static string connectionString = "Server=(localdb)\\MyInstance;Database=MyDatabase;Integrated Security=true;"; public static void ExecuteCMD(string statement) { using (SqlConnection connection = new SqlConnection(connectionString)) { SqlCommand command = new SqlCommand(statement, connection); command.Connection.Open(); command.ExecuteNonQuery(); } } public static void SelectQuery(string query) { using (SqlConnection connection = new SqlConnection(connectionString)) { SqlCommand command = new SqlCommand(query, connection); command.Connection.Open(); SqlDataReader reader = command.ExecuteReader(); while (reader.Read()) { Console.WriteLine(reader.GetString(0)); } } } } ✅ Hier hoeven we geen objecten meer te maken om de methoden te gebruiken. ✅ Voorbeeld van gebruik:DbConnection.ExecuteCMD("INSERT INTO MyTable (Column1) VALUES ('Value1')"); DbConnection.SelectQuery("SELECT Column1 FROM MyTable"); ✅ Gebruik een helper class als: Je veelvuldig met een database communiceert. Je herbruikbare en gestructureerde code wilt schrijven. Je een centrale plek wilt voor database-interacties. ✅ Gebruik specifiek een static helper class als: Je geen objecten wilt instantiëren voor database-interacties. Je methoden overal in je applicatie wilt kunnen aanroepen. ✅ Een helper class centraliseert databaseconnecties en CRUD-methoden. ✅ Een non-static helper class vereist een objectinstantie, terwijl een static helper class direct kan worden aangeroepen. ✅ Gebruik using om de databaseconnectie automatisch te sluiten. ✅ Gebruik een helper class om efficiënter en gestructureerd met databases te werken.

9.2 - Project configureren

Sat, 21 Jun 2025 12:57:11 GMT

In deze paragraaf gaan we een bestaande database koppelen aan een C#-project in Rider en kijken hoe we een nieuwe database kunnen aanmaken binnen Rider, zonder Datagrip te gebruiken.✅ We gebruiken Microsoft.Data.SqlClient als de nieuwste SQL-clientbibliotheek voor C#.✅ Belangrijk: Maak eerst een database aan in Datagrip. Open een bestaand project of maak een nieuw project/solution aan in Rider. Ga naar File > Settings (Preferences op macOS). Navigeer naar Plugins. Zoek naar Database Tools and SQL en zorg ervoor dat deze plugin geïnstalleerd en ingeschakeld is. Ga naar View > Tool Windows > Database. Klik op het +-icoon om een nieuwe data source toe te voegen. Selecteer Microsoft SQL Server LocalDB. Indien er nog geen driver is geïnstalleerd, klik op Download Driver. Vul de juiste gegevens in: Instance: Selecteer de juiste LocalDB-instance. Authentication: Kies Windows Credentials. Database: Laat dit momenteel leeg. URL: Laat dit staan zoals het is. Test de connectie door op Test Connection te klikken. ✅ Als "Succeeded" verschijnt, werkt de verbinding correct! ❌ Indien er een foutmelding verschijnt, controleer de vorige stappen en los het probleem op. Meer uitleg over Rider database-instellingen vind je op JetBrains Rider Docs.✅ Gebruik de nieuwste Microsoft.Data.SqlClient package in plaats van System.Data.SqlClient. Ga naar Tools > NuGet > Manage NuGet Packages for Solution. Zoek naar Microsoft.Data.SqlClient. Installeer de package in je project. ✅ Plaats onderstaande code in je Program-klasse om te testen of de databaseverbinding werkt. ✅ LET OP: Pas de Instance en Database aan naar jouw gegevens!using System; using Microsoft.Data.SqlClient; class Program { static void Main() { try { // Connection string voor LocalDB string connectionString = "Server=(localdb)\\MyInstance;Database=MyDatabase;Integrated Security=true;"; // Nieuw SqlConnection object aanmaken using (SqlConnection con = new SqlConnection(connectionString)) { // Connectie openen con.Open(); // Als test: SQL Server-versie ophalen Console.WriteLine($"Connected to SQL Server {con.ServerVersion}"); } Console.WriteLine("Druk op ENTER om te stoppen."); Console.ReadLine(); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); } } } ✅ Als alles werkt, wordt de versie van SQL Server correct geprint! ✅ Indien je een foutmelding krijgt, controleer dan of de juiste instance en database zijn gebruikt.Nu gaan we bekijken hoe we een nieuwe database in Rider zelf kunnen aanmaken, zonder Datagrip te gebruiken.✅ Belangrijk: Zorg ervoor dat je reeds een LocalDB-instance hebt aangemaakt! Open een bestaand of nieuw project in Rider. Ga naar View > Tool Windows > Database. Klik op het +-icoon om een nieuwe data source toe te voegen. Selecteer Microsoft SQL Server LocalDB. Kies de juiste instance en zet Authentication op Windows Credentials. Klik op Test Connection om te controleren of de verbinding werkt. ✅ Als alles correct is, klik op OK om de data source toe te voegen. ✅ Gebruik de eerder gegeven code om de verbinding met de database te testen. Ga naar Tools > NuGet > Manage NuGet Packages for Solution. Zoek naar Microsoft.Data.SqlClient. Installeer de package in je project. Pas de connection string aan in je code naar de juiste databasegegevens. ✅ Installeer Database Tools and SQL in Rider om te werken met SQL Server LocalDB. ✅ Gebruik Microsoft.Data.SqlClient als de nieuwste SQL-clientbibliotheek. ✅ Maak een verbinding met een bestaande database via Rider en test de connectie. ✅ Gebruik File > Tool Windows > Database om een nieuwe database te maken in Rider. ✅ Gebruik een connection string om de verbinding met SQL Server te testen.

9.1 - Inleiding

Sat, 21 Jun 2025 12:54:59 GMT

In dit hoofdstuk onderzoeken we hoe we een connectie kunnen maken tussen een C#-project en een MS SQL Server database met de klassenbibliotheek Microsoft.Data.SqlClient.✅ Waarom een database koppelen aan C#? Maakt het mogelijk om gegevens op te slaan, op te vragen en te manipuleren. Biedt een gestructureerde manier om grote hoeveelheden data efficiënt te beheren. SQL Server LocalDB is een lichte versie van SQL Server, ideaal voor ontwikkeling en testen. ✅ Microsoft.Data.SqlClient is de nieuwste versie van de SQL-clientbibliotheek voor C#. Belangrijk: Microsoft.Data.SqlClient vervangt System.Data.SqlClient en biedt verbeterde prestaties, betere ondersteuning voor moderne features en extra beveiligingsopties. ✅ Deze klassen maken het mogelijk om SQL-query’s uit te voeren en gegevens op te halen binnen een C#-applicatie.✅ Voordat je een connectie maakt, moet je een database hebben in MS SQL Server.TIP: Maak eerst in DataGrip een nieuwe database aan om te testen of de connectie werkt.✅ Zorg ervoor dat: De database correct is aangemaakt en toegankelijk is. Je de juiste rechten hebt ingesteld voor gebruikers. Je weet welke tabellen en kolommen aanwezig zijn. ✅ Voordat je met C# en SQL werkt, moet je de basis van SQL begrijpen.We gebruiken het CRUD-principe:✅ Gebruik altijd de cursus van het vak Databases als referentie voor SQL-statements!✅ Wat is het verschil tussen een server database en een embedded database?✅ MS SQL Server LocalDB is een embedded database, ideaal voor ontwikkeling en testen.✅ Microsoft.Data.SqlClient biedt diverse voordelen ten opzichte van het verouderde System.Data.SqlClient:✅ MS SQL Server LocalDB maakt het mogelijk om een lichte database te gebruiken binnen een C#-applicatie. ✅ Microsoft.Data.SqlClient vervangt System.Data.SqlClient en biedt verbeterde prestaties en beveiliging. ✅ Voordat je een connectie maakt, moet je een database aanmaken en de juiste rechten instellen. ✅ Het CRUD-principe wordt gebruikt om gegevens te beheren binnen SQL Server. ✅ Een server database is geschikt voor grote applicaties, terwijl een embedded database ideaal is voor lokale opslag.

8.13 - Expressions

Sat, 21 Jun 2025 12:52:46 GMT

Een expression in C# is een combinatie van variabelen, operators en methoden die een waarde oplevert.✅ Wat is een expression? Een expression is een stukje code dat geëvalueerd kan worden tot een enkele waarde. Expressions kunnen variabelen, methoden, operatoren en zelfs lambda-expressies bevatten. Expressions worden gebruikt in berekeningen, vergelijkingen en logische operaties. ✅ Een expression kan een eenvoudige waarde zijn, zoals een getal of een variabele.int a = 5; // Expression: 5 int b = a + 3; // Expression: a + 3 bool isGroot = (b > 5); // Expression: b > 5 ✅ Hier worden verschillende expressies geëvalueerd tot een waarde.✅ Expressions kunnen worden gebruikt voor wiskundige berekeningen.int x = 10; int y = 5; int resultaat = x * y + 2; Console.WriteLine(resultaat); // Output: 52 ✅ Hier wordt de expressie x * y + 2 geëvalueerd tot 52.✅ Vergelijkings- en logische expressies worden gebruikt in if-statements en loops.int leeftijd = 20; bool isVolwassen = (leeftijd >= 18 && leeftijd < 65); if (isVolwassen) { Console.WriteLine("Je bent volwassen."); } ✅ Hier wordt de expressie leeftijd >= 18 && leeftijd < 65 geëvalueerd tot true of false.✅ Een lambda-expressie is een korte manier om een anonieme functie te definiëren.Func vierkant = x => x * x; Console.WriteLine(vierkant(5)); // Output: 25 ✅ Hier gebruiken we een lambda-expressie om een functie te definiëren die een getal kwadrateert.✅ Expression Trees maken het mogelijk om expressies als objecten te manipuleren.using System; using System.Linq.Expressions; Expression> vierkant = x => x * x; Console.WriteLine(vierkant); // Output: x => (x * x) ✅ Hier slaan we een expressie op als een object dat later kan worden geanalyseerd of gewijzigd.✅ Gebruik expressions als: Je een waarde wilt berekenen of evalueren. Je een logische vergelijking wilt uitvoeren. Je een lambda-expressie wilt gebruiken voor kortere functies. Je een Expression Tree wilt maken voor dynamische query’s. ✅ Expressions zijn combinaties van variabelen, operators en methoden die een waarde opleveren. ✅ Gebruik expressions voor berekeningen, vergelijkingen en logische operaties. ✅ Lambda-expressies bieden een korte manier om functies te definiëren. ✅ Expression Trees maken het mogelijk om expressies als objecten te manipuleren.

8.12 - LINQ

Sat, 21 Jun 2025 12:51:04 GMT

LINQ staat voor Language Integrated Query en is een krachtige manier om gegevens te filteren, sorteren en groeperen binnen C#.✅ Wat is LINQ? LINQ maakt het mogelijk om query’s te schrijven binnen C# zonder een aparte query-taal zoals SQL te gebruiken. Je kunt LINQ gebruiken om gegevens op te vragen uit arrays, lists, XML-documenten en andere collecties. LINQ maakt code leesbaarder en efficiënter door declaratieve query’s te gebruiken. ### 8.12.1 – Waarom LINQ gebruiken?✅ Voordelen van LINQ: Eenvoudige en leesbare query-syntaxis → Minder complexe loops en if-statements. Sterke typecontrole → Voorkomt fouten tijdens compilatie. Consistente manier om gegevens te verwerken → Werkt met verschillende soorten collecties. Minder code nodig → Kortere en efficiëntere query’s. ✅ Een LINQ-query bestaat uit drie stappen: Definieer de gegevensbron → Bijvoorbeeld een array of een lijst. Maak de query → Gebruik LINQ-syntaxis om gegevens te filteren of te sorteren. Voer de query uit → Gebruik een foreach-loop om de resultaten te verwerken. ✅ Gebruik LINQ om gegevens uit een array te filteren.int[] scores = { 97, 92, 81, 60 }; // LINQ-query definiëren var scoreQuery = from score in scores where score > 80 select score; // Query uitvoeren foreach (int i in scoreQuery) { Console.WriteLine(i); } 97 92 81 ✅ Hier filteren we alle getallen groter dan 80 uit de array.✅ Naast de declaratieve query-syntaxis kun je LINQ ook schrijven met methodes.int[] scores = { 97, 92, 81, 60 }; var scoreQuery = scores.Where(score => score > 80); foreach (int i in scoreQuery) { Console.WriteLine(i); } ✅ Hier gebruiken we Where() om dezelfde filter toe te passen als in het vorige voorbeeld. ✅ Methodesyntaxis is vaak korter en directer dan query-syntaxis.✅ LINQ werkt ook met List en andere collecties.List namen = new List { "Aragorn", "Frodo", "Gandalf", "Legolas" }; var langeNamen = from naam in namen where naam.Length > 6 select naam; foreach (string naam in langeNamen) { Console.WriteLine(naam); } Aragorn Gandalf Legolas ✅ Hier filteren we alle namen langer dan 6 tekens uit de lijst.✅ LINQ bevat ingebouwde methoden om gegevens te sorteren en groeperen.List cijfers = new List { 75, 92, 88, 60, 99 }; var gesorteerdeCijfers = cijfers.OrderBy(c => c); foreach (int cijfer in gesorteerdeCijfers) { Console.WriteLine(cijfer); } 60 75 88 92 99 ✅ Hier sorteren we de lijst van cijfers in oplopende volgorde.✅ Gebruik LINQ als: Je gegevens wilt filteren, sorteren of groeperen zonder complexe loops. Je een consistente manier wilt om verschillende soorten collecties te verwerken. Je minder code wilt schrijven en de leesbaarheid wilt verbeteren. ✅ LINQ maakt het mogelijk om declaratieve query’s te schrijven binnen C#. ✅ Gebruik LINQ om gegevens te filteren, sorteren en groeperen zonder complexe loops. ✅ LINQ werkt met arrays, Lists en andere collecties. ✅ Gebruik OrderBy(), Where() en GroupBy() om gegevens efficiënt te verwerken. ✅ LINQ-query’s kunnen worden geschreven in declaratieve query-syntaxis of methodesyntaxis.

8.11 - Paden

Sat, 21 Jun 2025 12:47:33 GMT

Bij het werken met bestanden en mappen in C# is het belangrijk om te begrijpen hoe paden werken.✅ Wat is een pad? Een pad is een verwijzing naar de locatie van een bestand of map op een computer. Er zijn twee soorten paden: absolute en relatieve paden. ✅ Een absoluut pad geeft de volledige locatie van een bestand of map, inclusief de hoofdmap (root).C:\Gebruikers\RJA\Documenten\voorbeeld.txt /home/rja/documenten/voorbeeld.txt ✅ Een absoluut pad werkt altijd, ongeacht de huidige locatie van het programma. ✅ Het is een directe verwijzing naar een bestand of map zonder afhankelijk te zijn van de huidige directory.✅ Een relatief pad verwijst naar een bestand of map ten opzichte van de huidige werkdirectory.documenten/voorbeeld.txt ✅ Hier wordt het bestand voorbeeld.txt gezocht in de documenten-map binnen de huidige directory. ✅ Relatieve paden zijn handig als je een project verplaatst naar een andere locatie zonder de code te hoeven aanpassen.✅ Gebruik een absoluut pad als je een vaste locatie wilt gebruiken. ✅ Gebruik een relatief pad als je flexibiliteit nodig hebt binnen een project.✅ Gebruik Path.Combine() om een pad dynamisch te bouwen.using System; using System.IO; class Program { static void Main() { string relatiefPad = "documenten/voorbeeld.txt"; string absoluutPad = Path.GetFullPath(relatiefPad); Console.WriteLine($"Relatief pad: {relatiefPad}"); Console.WriteLine($"Absoluut pad: {absoluutPad}"); } } ✅ Hier zetten we een relatief pad om naar een absoluut pad met Path.GetFullPath().✅ Gebruik een absoluut pad als: Je een vaste locatie wilt gebruiken die niet verandert. Je werkt met systeembestanden of externe opslag. ✅ Gebruik een relatief pad als: Je een project flexibel wilt houden bij verplaatsing. Je bestanden binnen een applicatie wilt beheren zonder afhankelijk te zijn van een vaste locatie. ✅ Een pad verwijst naar de locatie van een bestand of map op een computer. ✅ Absolute paden geven de volledige locatie, terwijl relatieve paden afhankelijk zijn van de huidige directory. ✅ Gebruik Path.GetFullPath() om een relatief pad om te zetten naar een absoluut pad. ✅ Gebruik Path.Combine() om paden dynamisch te bouwen.

8.10 - Files

Sat, 21 Jun 2025 12:45:34 GMT

In deze paragraaf behandelen we bestandsbeheer in C#, inclusief het lezen, schrijven en maken van .txt-bestanden.✅ Waarom bestanden gebruiken? Bestanden worden gebruikt om gegevens permanent op te slaan. Ze maken het mogelijk om informatie te bewaren, zelfs nadat een programma is afgesloten. C# biedt ingebouwde methoden om eenvoudig met bestanden te werken. ✅ Gebruik File.Create() om een nieuw bestand aan te maken.using System.IO; File.Create("voorbeeld.txt"); Console.WriteLine("Bestand aangemaakt!"); ✅ Hier maken we een nieuw bestand voorbeeld.txt aan in de huidige directory. ✅ Als het bestand al bestaat, wordt het overschreven.✅ Gebruik File.WriteAllText() om tekst naar een bestand te schrijven.using System.IO; string tekst = "Dit is een voorbeeldtekst."; File.WriteAllText("voorbeeld.txt", tekst); Console.WriteLine("Tekst geschreven naar bestand!"); ✅ Hier schrijven we een string naar voorbeeld.txt. ✅ Als het bestand al bestaat, wordt de inhoud overschreven.✅ Gebruik File.AppendAllText() om tekst toe te voegen zonder bestaande inhoud te overschrijven.using System.IO; string extraTekst = "Dit is een extra regel."; File.AppendAllText("voorbeeld.txt", extraTekst + Environment.NewLine); Console.WriteLine("Tekst toegevoegd aan bestand!"); ✅ Hier voegen we een extra regel toe aan voorbeeld.txt, zonder de bestaande inhoud te verwijderen.✅ Gebruik File.ReadAllText() om de volledige inhoud van een bestand te lezen.using System.IO; string inhoud = File.ReadAllText("voorbeeld.txt"); Console.WriteLine($"Bestandsinhoud:\n{inhoud}"); ✅ Hier lezen we de volledige inhoud van voorbeeld.txt en tonen deze in de console.✅ Gebruik File.ReadAllLines() om een bestand regel voor regel te lezen.using System.IO; string[] regels = File.ReadAllLines("voorbeeld.txt"); foreach (string regel in regels) { Console.WriteLine(regel); } ✅ Hier lezen we elke regel afzonderlijk en tonen deze in de console.✅ Gebruik File.Delete() om een bestand te verwijderen.using System.IO; File.Delete("voorbeeld.txt"); Console.WriteLine("Bestand verwijderd!"); ✅ Hier verwijderen we voorbeeld.txt uit de directory.✅ Gebruik try-catch om fouten bij bestandsbeheer op te vangen.using System; using System.IO; try { string inhoud = File.ReadAllText("nietbestaand.txt"); Console.WriteLine(inhoud); } catch (FileNotFoundException) { Console.WriteLine("Fout: Bestand niet gevonden!"); } catch (Exception e) { Console.WriteLine($"Algemene fout: {e.Message}"); } ✅ Hier vangen we een FileNotFoundException op als het bestand niet bestaat.✅ Gebruik File.Create() om een nieuw bestand aan te maken. ✅ Gebruik File.WriteAllText() om tekst naar een bestand te schrijven. ✅ Gebruik File.AppendAllText() om tekst toe te voegen zonder bestaande inhoud te overschrijven. ✅ Gebruik File.ReadAllText() om een bestand volledig te lezen. ✅ Gebruik File.ReadAllLines() om een bestand regel voor regel te lezen. ✅ Gebruik File.Delete() om een bestand te verwijderen. ✅ Gebruik try-catch om fouten bij bestandsbeheer op te vangen.

8.9 - Exceptions

Sat, 21 Jun 2025 12:44:12 GMT

In deze paragraaf gaan we dieper in op exceptions.✅ Wat is een exception? Een exception is een uitzonderlijke gebeurtenis die het normale verloop van een programma verstoort. Exceptions worden gegenereerd wanneer er een fout optreedt tijdens de uitvoering van een programma. Een exception moet worden opgevangen en afgehandeld om te voorkomen dat de applicatie crasht. ### 8.9.1 – Verschil tussen een exception en een error✅ Een error is een fundamentele fout in de code → Bijvoorbeeld een ontbrekende klasse of een verkeerd bestand. ✅ Een exception is een runtime-fout → Bijvoorbeeld een verkeerde invoer of een poging om een niet-bestaand object te gebruiken.✅ Laten we een eenvoudige exception genereren om te zien hoe het systeem reageert.Console.WriteLine("Geef een getal in cijfers:"); int getal = Convert.ToInt32(Console.ReadLine()); ✅ Als de gebruiker een string invoert in plaats van een getal, zal dit een FormatException genereren.Unhandled exception. System.FormatException: Input string was not in a correct format. ✅ De foutmelding geeft aan dat de invoer niet correct is en waar de fout zich bevindt in de code.✅ Gebruik een try-catch-blok om exceptions op te vangen en af te handelen.try { // Code die mogelijk een exception kan veroorzaken } catch (Exception e) { // Code om de exception af te handelen } ✅ Drie manieren om een catch-blok te schrijven:✅ Je kunt meerdere catch-blokken gebruiken om verschillende soorten exceptions op te vangen.try { int getal = Convert.ToInt32(Console.ReadLine()); } catch (FormatException) { Console.WriteLine("Verkeerd invoertype!"); } catch (Exception e) { Console.WriteLine($"Algemene fout: {e.Message}"); } ✅ Hier vangen we eerst een FormatException op en daarna een algemene Exception.✅ Een exception-object (e) bevat nuttige informatie over de fout.catch (Exception e) { Console.WriteLine($"Exception opgetreden!"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"TargetSite: {e.TargetSite}"); Console.WriteLine($"StackTrace: {e.StackTrace}"); } ✅ Hier loggen we de foutinformatie naar de console.✅ Het finally-blok wordt altijd uitgevoerd, ongeacht of er een exception optreedt. Om resources vrij te geven → Bijvoorbeeld het sluiten van een bestand of databaseverbinding. Om cleanup-code uit te voeren → Bijvoorbeeld het resetten van variabelen. Om ervoor te zorgen dat bepaalde code altijd wordt uitgevoerd. ✅ Gebruik finally om ervoor te zorgen dat bepaalde code altijd wordt uitgevoerd.try { Console.WriteLine("Opening bestand..."); throw new Exception("Bestand niet gevonden!"); } catch (Exception e) { Console.WriteLine($"Fout: {e.Message}"); } finally { Console.WriteLine("Bestand gesloten."); } Opening bestand... Fout: Bestand niet gevonden! Bestand gesloten. ✅ Hier wordt het finally-blok altijd uitgevoerd, zelfs als er een exception optreedt.✅ Exceptions zijn runtime-fouten die het normale verloop van een programma verstoren. ✅ Gebruik try-catch om exceptions op te vangen en af te handelen. ✅ Gebruik meerdere catch-blokken om verschillende soorten exceptions op te vangen. ✅ Gebruik finally om cleanup-code uit te voeren, ongeacht of er een exception optreedt.

8.7 - Lists

Sat, 21 Jun 2025 12:40:44 GMT

In hoofdstuk 6 hebben we geleerd wat arrays zijn en hoe belangrijk deze zijn binnen applicatieontwikkeling.Het grootste nadeel van een array is dat deze nooit van grootte kan veranderen.✅ Een List lost dit probleem op! Een List lijkt op een array, maar kan dynamisch groeien of krimpen. Een List is onderdeel van Collections in C#, een verzameling van geavanceerde datastructuren. Een List bevat ingebouwde methoden om eenvoudig elementen toe te voegen, te verwijderen en te manipuleren. ### 8.7.1 – Wat is een `List`?Een List is een dynamische versie van een array, met meer functionaliteit en flexibiliteit.✅ Verschillen tussen een array en een List✅ Gebruik een List als je een variabele groep gegevens wilt beheren zonder de grootte vooraf te moeten bepalen.We kunnen een List dus niet zomaar vergelijken met een Ikea vakkenkast (zie 6.0 - Inleiding). Een array heeft immers een vaste lengte en een List niet. Maar als we even onze fantasie gebruiken, kunnen we wel een aanpasbaar vakkenkastje bedenken, dat kan groeien en krimpen afhankelijk van het aantal elementen dat erin moeten.✅ Een List declareren werkt vergelijkbaar met een array, maar zonder een vaste grootte te definiëren.List namen = new List { "Amrod", "Feanor", "Galadriel", "Legolas" }; ✅ Hier maken we een lijst van string zonder vooraf een grootte te hoeven opgeven. ✅ Een List kan later elementen toevoegen en verwijderen zonder beperkingen.✅ Gebruik Add() om een nieuw element toe te voegen aan een List.List personages = new List(); personages.Add("Darth Vader"); personages.Add("Luke Skywalker"); foreach (var naam in personages) { Console.WriteLine(naam); } Darth Vader Luke Skywalker ✅ Hier voegen we twee namen toe zonder de oorspronkelijke lijst opnieuw te moeten definiëren!✅ Een List bevat veel handige ingebouwde methoden.List steden = new List { "Amsterdam", "Brussel", "Parijs", "Berlijn" }; steden.RemoveAt(2); // Verwijdert "Parijs" foreach (var stad in steden) { Console.WriteLine(stad); } Amsterdam Brussel Berlijn ✅ Hier verwijderen we Parijs uit de lijst zonder de rest van de elementen aan te passen.✅ Net zoals arrays, kun je een List eenvoudig doorlopen met een foreach-loop.List namen = new List { "Aragorn", "Frodo", "Gandalf" }; foreach (string naam in namen) { Console.WriteLine(naam); } Aragorn Frodo Gandalf ✅ Hier hoeven we geen handmatige indexering te gebruiken zoals bij een for-loop!✅ Gebruik een List als: Je een dynamische collectie van gegevens wilt beheren. Je eenvoudig elementen wilt toevoegen en verwijderen. Je de ingebouwde methoden wilt gebruiken voor manipulatie van gegevens. ❌ Gebruik een array als: De grootte van de collectie vaststaat en niet verandert. Je een eenvoudige en snelle opslagstructuur nodig hebt. ✅ Een List is een geavanceerde versie van een array die dynamisch kan groeien en krimpen. ✅ Gebruik Add() om elementen toe te voegen en RemoveAt() om elementen te verwijderen. ✅ Een List bevat ingebouwde methoden zoals Insert(), IndexOf(), Clear() en Count(). ✅ Gebruik een foreach-loop om eenvoudig door een List te itereren.

8.1 - Polymorfisme

Sat, 21 Jun 2025 12:29:51 GMT

Een belangrijk concept binnen Object-Oriented Programming (OOP) is polymorfisme.✅ Wat is polymorfisme? Polymorfisme betekent dat objecten van verschillende klassen op dezelfde manier kunnen worden behandeld. Maakt het mogelijk om een enkele interface te gebruiken voor verschillende typen objecten. Vergroot de flexibiliteit en herbruikbaarheid van code. ✅ Voordelen van polymorfisme: Generieke code schrijven → Eén methode kan werken met meerdere objecttypen. Vermindert duplicatie → Minder herhaling van code. Verbeterde uitbreidbaarheid → Makkelijker om nieuwe klassen toe te voegen zonder bestaande code aan te passen. C# ondersteunt twee vormen van polymorfisme: ✅ Compile-time polymorfisme (Method Overloading) ✅ Runtime polymorfisme (Method Overriding)✅ Hier kunnen methoden met dezelfde naam meerdere versies hebben met verschillende parameters. ✅ De compiler kiest automatisch de juiste methode gebaseerd op de argumenten die worden meegegeven.class Rekenmachine { public int Optellen(int a, int b) { return a + b; } public double Optellen(double a, double b) { return a + b; } } Rekenmachine calc = new Rekenmachine(); Console.WriteLine(calc.Optellen(5, 3)); // Output: 8 (int) Console.WriteLine(calc.Optellen(5.5, 3.2)); // Output: 8.7 (double) ✅ De juiste methode wordt automatisch geselecteerd op basis van de invoer. ✅ Dit is een vorm van polymorfisme die al bij het compileren wordt bepaald.✅ Hier kan een childklasse een methode overschrijven van de parentklasse. ✅ De juiste methode wordt pas gekozen tijdens runtime.class Dier { public virtual void MaakGeluid() { Console.WriteLine("Dier maakt geluid"); } } class Hond : Dier { public override void MaakGeluid() { Console.WriteLine("Woef!"); } } class Kat : Dier { public override void MaakGeluid() { Console.WriteLine("Miauw!"); } } Dier dier1 = new Hond(); Dier dier2 = new Kat(); dier1.MaakGeluid(); // Output: Woef! dier2.MaakGeluid(); // Output: Miauw! ✅ Hier behandelen we objecten als Dier, maar ze hebben een eigen gedrag gebaseerd op hun subclass (Hond of Kat). ✅ Dit maakt polymorfisme krachtig in dynamische systemen.In bovenstaande ludieke afbeelding zien we drie objecten van klasse Dog, Cat en Cow, die alle drie overerven van klasse Animal. Via method overriding zullen alle drie de objecten een andere uitwerking van methode Speak() hebben.Met polymorfisme kunnen we een array maken die objecten van verschillende childklassen bevat, maar ze behandelen als hun parentklasse.✅ Voordeel: Hierdoor kunnen we één array gebruiken voor meerdere verschillende typen objecten, zolang ze een gemeenschappelijke parentklasse hebben.Stel dat we een parentklasse Dier hebben en verschillende childklassen Hond, Kat en Vogel.class Dier { public virtual void MaakGeluid() { Console.WriteLine("Dier maakt geluid"); } } class Hond : Dier { public override void MaakGeluid() { Console.WriteLine("Woef!"); } } class Kat : Dier { public override void MaakGeluid() { Console.WriteLine("Miauw!"); } } class Vogel : Dier { public override void MaakGeluid() { Console.WriteLine("Tsjilp!"); } } Nu kunnen we een array maken die alle soorten dieren bevat en ze behandelen als hun parentklasse Dier!Dier[] dieren = { new Hond(), new Kat(), new Vogel() }; foreach (Dier dier in dieren) { dier.MaakGeluid(); // Aanroepen van de overschreven methode } ✅ Hier behandelen we alle objecten als Dier, maar hun eigen geïmplementeerde versie van MaakGeluid() wordt uitgevoerd.Woef! Miauw! Tsjilp! ✅ Elke object roept zijn eigen overschreven methode aan, ondanks dat ze in dezelfde array zitten! ✅ Dit is de kracht van polymorfisme in combinatie met arrays.✅ Handig als je een lijst van objecten wilt beheren die allemaal van dezelfde parentklasse erven. ✅ Vermindert duplicatie van code, omdat je geen aparte arrays per type hoeft te maken. ✅ Maakt het gemakkelijk om een bewerking uit te voeren op alle objecten zonder specifieke type-checks.Naast method overloading en method overriding, kun je interfaces gebruiken om polymorfisme toe te passen. Interfaces komen later in de cursus aan bod, maar toch leggen we hier graag uit hoe dit binnen het verhaal van polymorfisme past.✅ Een interface definieert een set methoden die moeten worden geïmplementeerd door verschillende klassen.interface IVoertuig { void Rijden(); } class Auto : IVoertuig { public void Rijden() { Console.WriteLine("Auto rijdt op de weg."); } } class Fiets : IVoertuig { public void Rijden() { Console.WriteLine("Fiets rijdt op het fietspad."); } } IVoertuig voertuig1 = new Auto(); IVoertuig voertuig2 = new Fiets(); voertuig1.Rijden(); // Output: Auto rijdt op de weg. voertuig2.Rijden(); // Output: Fiets rijdt op het fietspad. ✅ Hier behandelen we verschillende objecten (Auto, Fiets) als een algemeen IVoertuig type. ✅ Dit maakt het mogelijk om meerdere klassen dezelfde interface te laten gebruiken zonder afhankelijk te zijn van specifieke implementaties.✅ Polymorfisme maakt het mogelijk om objecten van verschillende klassen op dezelfde manier te behandelen. ✅ Er zijn twee soorten polymorfisme: compile-time (overloading) en runtime (overriding). ✅ Method overloading maakt gebruik van meerdere versies van dezelfde methode met verschillende parameters. ✅ Method overriding laat een childklasse een methode overschrijven van een parentklasse. ✅ Interfaces maken interface-gebaseerd polymorfisme mogelijk, waardoor verschillende klassen dezelfde methoden kunnen implementeren.

7.4 - Sealed

Sat, 21 Jun 2025 12:24:07 GMT

Een ander concept binnen overerving, is het keyword sealed.✅ Wat doet sealed? Voorkomt dat een klasse verder kan worden geërfd. Markeert een klasse als de “laatste in de lijn van overerving”. Kan helpen bij beveiliging en prestatie-optimalisatie. Door een klasse sealed te maken, bereiken we twee dingen:✅ 1. Voorkomen van verdere overerving Geen childklassen kunnen worden gemaakt van een sealed-klasse. Handig bij grote applicaties om te voorkomen dat klassen per ongeluk worden uitgebreid. ✅ 2. Kleine prestatieverbetering De compiler weet dat hij niet verder hoeft te zoeken naar childklassen. In grote applicaties kan dit een minimale snelheidswinst opleveren. ✅ Gebruik sealed voor klassen die niet verder geërfd mogen worden.abstract class GeometrischFiguur { public abstract string Naam(); } sealed class Vierkant : GeometrischFiguur { public override string Naam() { return "Ik ben een vierkant!"; } } ✅ Hier kan Vierkant alleen een childklasse zijn, maar niet verder worden uitgebreid. ✅ Je kunt geen extra klassen maken die van Vierkant erven.Een sealed klasse kan niet verder geërfd worden.class Kubus : Vierkant // ERROR: Kan niet erven van sealed klasse! { } ❌ Dit zal een compiler error geven, omdat Vierkant sealed is!✅ Gebruik sealed als: Je niet wilt dat een klasse verder kan worden uitgebreid. Je een definitieve implementatie wilt garanderen. Je een beveiligingslaag wilt toevoegen tegen ongewenste wijzigingen. ❌ Gebruik sealed niet als: Je flexibiliteit nodig hebt en verdere uitbreiding van de klasse verwacht. Hoewel sealed voordelen heeft, zijn er ook nadelen:❌ Kan problematisch zijn in grote teams → Andere programmeurs kunnen de klasse niet uitbreiden. ❌ Beperkt aanpasbaarheid → Als je later een extra childklasse wilt toevoegen, moet je sealed verwijderen. ❌ Wordt weinig gebruikt → In de praktijk is sealed niet vaak nodig.✅ Sealed voorkomt verdere overerving van een klasse. ✅ Handig als je een definitieve implementatie wilt vastleggen. ✅ Kan zorgen voor een kleine prestatieverbetering (maar niet merkbaar bij kleine apps). ✅ Gebruik sealed alleen als verdere uitbreiding van een klasse niet gewenst is. ✅ In de praktijk wordt sealed niet vaak gebruikt.

7.2 - Method overriding

Sat, 21 Jun 2025 12:20:58 GMT

In de vorige paragrafen hebben we geleerd dat childklassen variabelen, constanten, properties en methoden kunnen overerven van hun parentklasse.Dit is zeer handig, maar soms willen we een methode uit de parentklasse aanpassen in de childklasse.Bij method overriding kunnen we: ✅ Een geërfde methode uitbreiden zonder de naam te wijzigen. ✅ Een methode volledig herschrijven binnen de childklasse, maar met dezelfde naam.Hier komen de keywords virtual en override kijken!Method Overriding is een vorm van polymorfisme.Het woord polymorfisme komt van het Oudgrieks: poly = meerdere morf = vorm Een bekend voorbeeld van polymorfisme is water: ✅ Water kan solide, vloeibaar of gasvormig zijn, maar blijft water.Binnen OOP betekent polymorfisme dat een methode verschillende vormen kan aannemen.✅ Gebruik virtual in de parentklasse als je wilt dat een methode overschreven kan worden in de childklasse.class Wegvoertuig { public virtual void GasGeven() { Console.WriteLine("Vroem!"); } } ✅ Hier geven we aan dat GasGeven() kan worden overschreven door childklassen. ✅ Als een childklasse niets overschrijft, blijft de originele methode behouden.✅ Gebruik override in de childklasse om een geërfde methode te overschrijven.class Stadsauto : Wegvoertuig { public override void GasGeven() { Console.WriteLine("Stadsauto doet vroem!"); } } class Vrachtwagen : Wegvoertuig { public override void GasGeven() { Console.WriteLine("Vrachtwagen doet VROEM!!"); } } ✅ Stadsauto en Vrachtwagen hebben een eigen implementatie van GasGeven(). ✅ Hierdoor reageren de childklassen anders dan de parentklasse!Wegvoertuig wegvoertuig = new Wegvoertuig(); Stadsauto stadsauto = new Stadsauto(); Vrachtwagen vrachtwagen = new Vrachtwagen(); wegvoertuig.GasGeven(); stadsauto.GasGeven(); vrachtwagen.GasGeven(); Output:Vroem! Stadsauto doet vroem! Vrachtwagen doet VROEM!! ✅ De virtual methode in Wegvoertuig is overschreven in Stadsauto en Vrachtwagen. ✅ Hierdoor heeft elke childklasse een unieke manier om GasGeven() uit te voeren.Op bovenstaande afbeelding is schematisch method overriding te zien. Animal is de superklasse van Dog. De methode Eat() wordt doorgegeven aan Dog (daarom staat die ook niet tussen de methods van Dog). De methode Bark() is een nieuwe methode van klasse Dog. De methode Move() staat in zowel klasse Animal als klasse Dog. Dit betekent dat deze methode wordt overridden.✅ Een methode in de parentklasse moet virtual, abstract of override zijn om overschreven te kunnen worden. ✅ Een overschreven methode in de childklasse moet override gebruiken. ✅ Je kunt een virtual methode ook laten uitvoeren in de childklasse voordat je deze overschrijft. ✅ Een virtual methode kan nooit static zijn!✅ Method Overriding is een vorm van polymorfisme. ✅ Gebruik virtual in de parentklasse om methoden overschrijfbaar te maken. ✅ Gebruik override in de childklasse om de methode te overschrijven. ✅ Elke childklasse kan een unieke versie van een geërfde methode hebben. ✅ Een virtual methode kan nooit static zijn.

7.0 - Inleiding

Sat, 21 Jun 2025 12:10:31 GMT

In dit hoofdstuk behandelen we een belangrijk concept binnen Object-Oriented Programming (OOP): overerving (in het Engels: inheritance).We willen als programmeurs zo min mogelijk code herhalen. Hoe meer we kunnen hergebruiken, des te beter en efficiënter ons programma wordt!Daarnaast helpt overerving om te leren werken met abstracte en concrete concepten. Bijvoorbeeld: ✅ Een geometrisch figuur is een abstract concept, maar een vierkant is concreet. ✅ Een sportauto is een auto, een hond is een dier, en een laptop is een computer.Overerving betekent dat een klasse eigenschappen en methoden kan erven van een andere klasse.✅ Superklasse (Parent Class) → De basisklasse die eigenschappen doorgeeft. ✅ Subklasse (Child Class) → Een klasse die eigenschappen en methoden overneemt van de superklasse.Dit volgt een "x-is-een-y"-relatie: Een hond is een dier. Een sportauto is een auto. Een laptop is een computer. Let op: Dit verschilt van "x-heeft-een-y" (compositie), wat later in de cursus wordt behandeld! Op bovenstaande afbeelding zien we klasse A, B, C en D. Klasse A is hier de superklasse. De andere klassen zijn hiervan de subklassen en kunnen gebruik gaan maken van variabelen, properties, methoden, etc. uit klasse A.Subklassen kunnen op hun beurt ook weer superklassen zijn van andere klassen.✅ C# ondersteunt overerving met het :-symbool.class ChildClass : ParentClass { // ChildClass erft eigenschappen en methoden van ParentClass } ✅ Een afgeleide klasse kan methoden en eigenschappen van de hoofdklasse gebruiken. ✅ Je kunt de eigenschappen van de hoofdklasse uitbreiden of overschrijven (zie Method Overriding in 7.2).Laten we een voorbeeld nemen van een geometrisch figuur.Een vierkant is een geometrisch figuur, dus het erft eigenschappen van de Figuur-klasse.class Figuur { public int Zijdes; } class Vierkant : Figuur { public Vierkant() { Zijdes = 4; // Vierkanten hebben altijd vier zijdes } } ✅ Vierkant erft de eigenschappen van Figuur. ✅ Hierdoor hoeft Vierkant de eigenschap Zijdes niet opnieuw te definiëren.✅ Relaties tussen klassen kunnen visueel worden weergegeven met UML-diagrammen. ✅ UML staat voor Unified Modeling Language. ✅ Overerving wordt weergegeven door middel van een pijl van de child naar de parent klasse.Levend Wezen ├── Dier │ └── Paard ├── Plant └── Tulp ✅ Een paard is een dier, en een dier is een levend wezen. ✅ Een tulp is een plant, en een plant is ook een levend wezen. ✅ Deze hiërarchie helpt bij het structureren van klassen binnen een project.
Op bovenstaande afbeelding is een zeer simpel UML-diagram te zien. De klasse Automobile is hier de superklasse van Car en Bus, die op hun beurt ook weer superklassen zijn van respectievelijk Ford en BMW, en Toyota en Mitsubishi.✅ Child-klassen erven methoden en properties van de parent-klasse. ✅ Private variabelen worden wel geërfd, maar zijn niet toegankelijk binnen de childklasse!class Dier { private int geboortejaar; } class Paard : Dier { public void MaakOuder() { geboortejaar++; // FOUT! Private variabele is niet toegankelijk. } } ❌ Dit zal een compiler error geven!✅ Gebruik protected om een variabele toegankelijk te maken in een childklasse.class Dier { protected int geboortejaar; } class Paard : Dier { public void MaakOuder() { geboortejaar++; // Dit werkt WEL! } } ✅ Hier kunnen child-klassen de protected variabelen wel benaderen.Gebruik protected in plaats van private als child-klassen toegang moeten hebben tot de variabelen van een parentklasse.✅ C# ondersteunt enkel enkele overerving** (geen meerdere parent-klassen tegelijk!).class Paard : Dier, Zoogdier // FOUT! Meerdere parent-klassen niet toegestaan. { } ❌ Dit zal een compiler error geven!Oplossing? Gebruik interfaces als je meerdere functionaliteiten wilt combineren.Meer uitleg over interfaces komt later in de cursus!✅ Gebruik sealed als je wilt voorkomen dat een klasse kan worden geërfd.sealed class Hamster { // Geen enkele andere klasse kan erven van Hamster! } ✅ Hiermee voorkom je dat Hamster als parentklasse kan worden gebruikt.✅ Overerving vermindert duplicatie en verbetert modulariteit. ✅ Een parent-class geeft eigenschappen door aan child-classes. ✅ Gebruik : in C# om een klasse te laten erven van een andere klasse. ✅ Gebruik protected als child-klassen toegang moeten hebben tot parent-variabelen. ✅ Gebruik sealed om overerving te blokkeren. ✅ C# ondersteunt geen meerdere parent-klassen (gebruik interfaces als alternatief).In de volgende paragraaf behandelen we constructors in overerving, waarmee je gecontroleerd eigenschappen kunt overdragen!

6.0 - Inleiding

Sat, 21 Jun 2025 11:57:02 GMT

Arrays zijn een veelgebruikt concept in vele programmeertalen.Het grote voordeel van arrays is dat je één enkele variabele kunt hebben die een grote groep waarden van eenzelfde type bevat.✅ Voordelen van arrays: Code wordt leesbaarder → Minder losse variabelen. Eenvoudiger onderhoud → Je hoeft niet elke variabele apart te beheren. Efficiënt geheugenbeheer → Alle waarden worden opgeslagen in één blok geheugen. Maar arrays hebben ook nadelen: ❌ De lengte van een array kan niet worden gewijzigd na creatie. ❌ Je moet vooraf weten hoeveel elementen je nodig hebt.Later in de cursus leren we Lists, die dit nadeel niet hebben.Een array is een verzameling variabelen van hetzelfde datatype (bijvoorbeeld een verzameling int, double of char).Deze waarden kunnen worden benaderd via één enkele variabele, de array zelf.✅ Elke waarde in een array heeft een index → Hiermee kun je elementen aanpassen of uitlezen.Je kunt een array vergelijken met een vakkenkast van Ikea: een vast aantal opbergplaatsen om je dozen in te stoppen. Je kunt hierbij zelf kiezen op welke plaats je een doos zet. Het enige waar je op moet letten is dat de dozen van hetzelfde materiaal gemaakt zijn (dezelfde datatypes), maar de inhoud van elke doos kan uiteraard verschillen. Onderstaande afbeelding van een Ikea Kallax vakkenkast zou je kunnen zien als een array met 3 indexposities. Je kunt deze kast niet groter of kleiner maken, net zoals een array niet groter of kleiner kan worden:Stel dat we een programma schrijven om de dagelijkse hoeveelheid neerslag bij te houden.Zonder een array zou je dit als volgt doen:int dag1 = 34; int dag2 = 45; int dag3 = 0; int dag4 = 34; int dag5 = 12; int dag6 = 0; int dag7 = 23; Als we nu het gemiddelde willen berekenen:double gemiddelde = (dag1 + dag2 + dag3 + dag4 + dag5 + dag6 + dag7) / 7; ✅ Dit werkt, maar is onhandig → Wat als we 365 dagen moeten bijhouden?Met een array kunnen we dit veel efficiënter doen:int[] regen = {34, 45, 0, 34, 12, 0, 23}; ✅ Alle waarden zitten nu in één variabele (regen). ✅ Je kunt eenvoudig door de array itereren.Elke plek binnen een array heet een indexpositie.✅ De eerste plaats binnen een array heeft indexpositie 0. ✅ Je begint dus te tellen vanaf nul:Indexpositie 0 → Waarde 34 Indexpositie 1 → Waarde 45 Indexpositie 2 → Waarde 0 ✅ Het derde element staat op indexpositie 2.Dit kan in het begin verwarrend zijn, maar wordt duidelijker na wat oefening!
Op bovenstaande afbeeldingen zien we een int array met 9 plaatsen/elementen. De totale lengte is 9, maar aangezien we beginnen te tellen vanaf 0, is indexpositie 8 de laatste plaats!Je kunt het gemiddelde berekenen door alle elementen op te tellen en te delen door de lengte van de array.double gemiddelde = (regen[0] + regen[1] + regen[2] + regen[3] + regen[4] + regen[5] + regen[6]) / 7; ❌ Dit is lang en foutgevoelig.int[] regen = {34, 45, 0, 34, 12, 0, 23}; // Array aanmaken double som = 0; foreach (var neerslag in regen) { som += neerslag; // Elk element optellen } double gemiddelde = som / regen.Length; // Delen door de lengte van de array Console.WriteLine($"Gemiddelde neerslag: {gemiddelde}"); ✅ Kortere en efficiëntere code. ✅ Geen handmatige indexering nodig. ✅ Automatisch de juiste lengte gebruiken (regen.Length).✅ Arrays groeperen meerdere waarden van hetzelfde datatype. ✅ Elke waarde in een array heeft een index (begint bij 0). ✅ De lengte van een array kan niet worden gewijzigd na creatie. ✅ Gebruik een foreach-loop om efficiënt door een array te itereren. ✅ Later leren we Lists, die flexibeler zijn dan arrays.

6.4 - Copy en Clone

Sat, 21 Jun 2025 11:50:44 GMT

Het is mogelijk om een array te kopiëren of te klonen, maar er zit een groot verschil tussen de twee.✅ Kopiëren → Je kopieert de inhoud van een array naar een andere array. ✅ Klonen → Je maakt een volledige kopie van een array als nieuw object.Bij het kopiëren van een array heb je: ✅ Een bestaande array (met waarden). ✅ Een lege array van hetzelfde datatype en minstens evenveel indexposities.string[] arrayEen = {"Ally", "Bishop", "Billy"}; string[] arrayTwee = new string[3]; arrayEen.CopyTo(arrayTwee, 0); // Kopieer vanaf index 0 ✅ Hier kopiëren we alle elementen van arrayEen naar arrayTwee. ✅ De tweede parameter (0) bepaalt vanaf welke indexpositie in arrayTwee de kopie begint.Je kunt een grotere array gebruiken en de kopie starten vanaf een andere index.string[] arrayEen = {"Ally", "Bishop", "Billy"}; string[] arrayTwee = new string[4]; arrayEen.CopyTo(arrayTwee, 1); // Start kopie vanaf index 1 ✅ Hier blijft indexpositie 0 in arrayTwee leeg (null). ✅ De kopie begint pas bij index 1.Als je niet weet hoe groot de originele array is, kun je de lengte van de eerste array gebruiken.string[] arrayEen = {"Ally", "Bishop", "Billy"}; string[] arrayTwee = new string[arrayEen.Length]; // Gebruik de lengte van arrayEen arrayEen.CopyTo(arrayTwee, 0); ✅ Hier wordt arrayTwee automatisch even groot als arrayEen.Meer uitleg over Array.Length vind je op Microsoft Learn.Bij klonen maak je een volledige kopie van een array als nieuw object.✅ Je hoeft geen tweede array vooraf te definiëren. ✅ Je hoeft geen startindex op te geven.string[] arrayEen = {"Ally", "Bishop", "Billy"}; var arrayTwee = (string[])arrayEen.Clone(); // Maak een exacte kopie ✅ Hier maken we een kopie van arrayEen zonder een tweede array vooraf te definiëren. ✅ We casten ((string[])) het gekloonde object naar een string-array.Meer uitleg over Array.Clone() vind je op Microsoft Learn.✅ Gebruik CopyTo() als je een bestaande array wilt kopiëren naar een andere array. ✅ Gebruik Clone() als je een volledig nieuw object wilt maken. ✅ Bij kopiëren moet je een tweede array vooraf definiëren. ✅ Bij klonen hoef je geen tweede array vooraf te definiëren. ✅ Gebruik .Length om de grootte van een array dynamisch te bepalen.

6.2 - Werken met arrays

Sat, 21 Jun 2025 11:46:55 GMT

Nu we weten hoe we een array kunnen aanmaken, gaan we bekijken hoe we met arrays kunnen werken.✅ Belangrijke operaties met arrays: Waarden toekennen → Een element in een array wijzigen. Waarden uitlezen → De waarde van een bepaald element ophalen. Lengte van een array opvragen → Bepalen hoeveel elementen een array bevat. Out-of-Range errors voorkomen → Voorkomen dat je een niet-bestaand element probeert te benaderen. ✅ Je kunt een waarde in een array wijzigen door de indexpositie aan te spreken.int[] cijfers = {8, 6, 22, 5033, 245}; cijfers[1] = 7; // Verander waarde van indexpositie 1 (van 6 naar 7) ✅ De waarde op indexpositie 1 (tweede element) is nu gewijzigd van 6 naar 7.✅ Je kunt een specifieke waarde uit een array opvragen door de indexpositie te gebruiken.Console.WriteLine(cijfers[3]); // Output: 5033 (waarde van indexpositie 3) ✅ Hier printen we de waarde van indexpositie 3 (het vierde element).Je kunt ook waarden combineren en een berekening uitvoeren.int som = cijfers[0] + cijfers[1]; // Optelt eerste en tweede element Console.WriteLine($"De som is: {som}"); ✅ Dit telt cijfers[0] (8) en cijfers[1] (7) op, wat 15 oplevert.✅ Je kunt de lengte van een array opvragen met .Length.string[] namen = {"Jan", "Pieter", "Erik"}; Console.WriteLine($"De grootte van de array is: {namen.Length}"); ✅ Hier vragen we de grootte van de array namen op, wat 3 zal zijn.Dit is vooral handig bij loops, zodat je niet handmatig de lengte hoeft te berekenen.Meer uitleg over array lengte vind je op Microsoft Learn.✅ De meest voorkomende foutmelding met arrays is de IndexOutOfRangeException.Dit gebeurt wanneer je een index probeert te gebruiken die niet bestaat.int[] cijfers = {8, 6, 22}; Console.WriteLine(cijfers[3]); // ERROR: Index 3 bestaat niet! ❌ Indexpositie 3 bestaat niet, omdat de array slechts 3 elementen heeft (0, 1, 2).✅ Voorkom deze fout door de lengte van de array te controleren.int index = 3; if (index < cijfers.Length) // Check of index binnen de lengte valt { Console.WriteLine(cijfers[index]); } else { Console.WriteLine("Fout: Index buiten bereik!"); } ✅ Hier controleren we of index kleiner is dan cijfers.Length voordat we de waarde opvragen.✅ Arrays bevatten meerdere waarden van hetzelfde datatype. ✅ Gebruik vierkante haken ([]) om specifieke elementen te benaderen. ✅ Gebruik .Length om de totale grootte van een array op te vragen. ✅ Voorkom IndexOutOfRangeException door altijd eerst de lengte te controleren. ✅ Later in de cursus leren we meer over Lists, een flexibeler alternatief voor arrays.

6.1 - Arrays maken

Sat, 21 Jun 2025 11:46:43 GMT

In de inleiding van dit hoofdstuk hebben we al wat voorbeelden gezien hoe een array eruit kan zien.In deze paragraaf gaan we dieper in op hoe een array precies is opgebouwd en hoe we deze kunnen aanmaken.Een array wordt gedeclareerd volgens de volgende structuur:datatype[] naamVanDeArray; ✅ Je moet eerst het datatype definiëren (int, string, double, etc.). ✅ Een array kan alleen één datatype bevatten (geen mix van int en string in dezelfde array). ✅ Gebruik vierkante haken ([]) om aan te geven dat het een array is. ✅ Geef de array een duidelijke naam.Wanneer we alleen een array declareren, bestaat deze nog niet echt.✅ De array wordt pas aangemaakt zodra we de grootte definiëren! ✅ Je moet aangeven hoeveel elementen de array bevat.string[] kleuren = new string[5]; // Array met 5 lege plaatsen ✅ Hiermee reserveer je ruimte voor 5 elementen, maar je weet nog niet welke waarden erin komen.Later kun je de waarden apart invullen:kleuren[0] = "rood"; kleuren[1] = "groen"; kleuren[2] = "geel"; kleuren[3] = "paars"; kleuren[4] = "blauw"; ✅ Voordeel: Je kunt later bepalen welke waarden er in de array komen. ✅ Nadeel: Je moet handmatig alle elementen invullen.string[] kleuren = { "rood", "groen", "geel", "paars", "blauw" }; ✅ Hiermee geef je direct de waarden op bij het aanmaken van de array. ✅ De grootte wordt automatisch bepaald aan de hand van het aantal elementen. ✅ Je hoeft de waarden niet later apart toe te voegen.✅ Voor flexibele arrays (waarbij je later waarden toevoegt), gebruik methode 1. ✅ Voor vaste arrays (waarbij je de waarden al kent), gebruik methode 2.Je mag geen array declareren zonder een grootte of initialisatie:string[] kleuren; // FOUT: Compiler weet niet hoe groot de array moet zijn! ✅ Je moet altijd een grootte opgeven (new string[5]) of direct waarden initialiseren ({ "rood", "groen", ... }).✅ Arrays groeperen meerdere waarden van hetzelfde datatype. ✅ Je moet altijd de grootte van een array definiëren. ✅ Twee manieren om een array te maken: eerst declareren of direct initialiseren. ✅ Gebruik vierkante haken ([]) om een array te definiëren. ✅ Later in de cursus leren we Lists, die flexibeler zijn dan arrays.

Programmeren

Fri, 20 Jun 2025 11:05:21 GMT

8.8 - Dictionaries

Fri, 20 Jun 2025 09:35:35 GMT

In paragraaf 8.7 hebben we geleerd wat Lists zijn en hoe deze worden gebruikt binnen applicatieontwikkeling.Een Dictionary is vergelijkbaar met een List, maar biedt extra functionaliteit door gegevens op te slaan als sleutel-waarde-paren.✅ Wat is een Dictionary? Een Dictionary is een dynamische datastructuur waarin elke waarde een unieke sleutel heeft. Onderdeel van Collections in C#, waarmee je efficiënt gegevens kunt beheren en opzoeken. Snelle zoekacties, doordat gegevens direct via een sleutel toegankelijk zijn. ### 8.8.1 – Waarom een Dictionary gebruiken?✅ Voordelen van een Dictionary: Efficiënt zoeken → De waarde wordt direct opgezocht via een unieke sleutel, zonder door de hele lijst te hoeven gaan. Flexibiliteit → Dynamisch toevoegen en verwijderen van gegevens. Gebruiksvriendelijkheid → Veel ingebouwde methoden om gegevens snel te beheren. ✅ Gebruik een List voor algemene lijsten en een Dictionary als je snel gegevens wilt opzoeken via een sleutel.✅ Een Dictionary declareren werkt vergelijkbaar met een List, maar je definieert een sleutel en een waarde.Dictionary studentScores = new Dictionary { { "Alice", 90 }, { "Bob", 85 }, { "Charlie", 92 } }; ✅ Hier definiëren we een Dictionary waarin elke student een cijfer heeft. ✅ Elke sleutel (string) heeft een bijbehorende waarde (int).✅ Gebruik Add() om een nieuw sleutel-waarde-paar toe te voegen aan een Dictionary.Dictionary studentScores = new Dictionary(); studentScores.Add("Alice", 90); studentScores.Add("Bob", 85); Console.WriteLine($"Alice's score: {studentScores["Alice"]}"); Alice's score: 90 ✅ Hier voegen we handmatig scores toe voor verschillende studenten.✅ Dictionaries bevatten veel ingebouwde methoden voor eenvoudig beheer.if (studentScores.ContainsKey("Bob")) { Console.WriteLine("Bob staat in de Dictionary."); } Bob staat in de Dictionary. ✅ Hier controleren we of een bepaalde sleutel aanwezig is voordat we een actie uitvoeren.✅ Net zoals Lists, kun je een Dictionary eenvoudig doorlopen met een foreach-loop.foreach (var kvp in studentScores) { Console.WriteLine($"Student: {kvp.Key}, Score: {kvp.Value}"); } Student: Alice, Score: 90 Student: Bob, Score: 85 Student: Charlie, Score: 92 ✅ Hier gebruiken we kvp.Key om de sleutel op te halen en kvp.Value om de waarde op te halen.✅ Gebruik een Dictionary als: Je een collectie van gegevens wilt beheren op basis van een unieke sleutel. Je snel toegang wilt tot specifieke waarden zonder door een lijst te hoeven zoeken. Je gegevens efficiënt wilt groeperen in sleutel-waarde-paren. ❌ Gebruik een List als: Je een gewone lijst van items nodig hebt zonder zoekopties op basis van een sleutel. Je iteraties wilt uitvoeren op een simpele, geordende collectie. ✅ Een Dictionary is een dynamische datastructuur die sleutel-waarde-paren gebruikt. ✅ Gebruik Add() om elementen toe te voegen en Remove() om elementen te verwijderen. ✅ Een Dictionary bevat ingebouwde methoden zoals ContainsKey(), Clear(), en Count(). ✅ Gebruik een foreach-loop om eenvoudig door een Dictionary te itereren.

8.6 - Events

Fri, 20 Jun 2025 09:32:01 GMT

Een event is een mechanisme waarmee een klasse andere klassen kan informeren wanneer er iets gebeurt.✅ Wat is een event? Events maken het mogelijk om een actie te laten plaatsvinden wanneer een bepaalde gebeurtenis optreedt. Een event wordt aangemaakt door een publisher en verwerkt door subscribers. Events worden vaak gebruikt in event-driven programmeren, zoals GUI-programma’s en asynchrone systemen. ✅ Voordelen van events: Losse koppeling → De publisher en subscriber hoeven elkaar niet direct te kennen. Flexibiliteit → Een event kan meerdere subscribers hebben. Efficiëntie → Events worden alleen geactiveerd wanneer nodig, waardoor ze minder resources verbruiken. Gebruik in GUI-programma’s → Events worden vaak gebruikt voor gebruikersinteracties zoals button-clicks. ✅ Events volgen het publisher/subscriber-patroon: De publisher → De klasse die het event aanmaakt en activeert. De subscriber → De klasse die reageert op het event. ✅ Gebruik het event keyword om een event te definiëren.public delegate void MijnEventHandler(string boodschap); public class EventVoorbeeld { public event MijnEventHandler MijnEvent; public void ActiveerEvent() { if (MijnEvent != null) { MijnEvent("Event geactiveerd!"); } } } ✅ Hier definiëren we een event MijnEvent dat een string als parameter accepteert. ✅ Het event wordt alleen geactiveerd als er subscribers zijn.✅ Een subscriber kan zich registreren voor een event en een methode koppelen die wordt uitgevoerd wanneer het event plaatsvindt.public class Program { public static void EventHandler(string boodschap) { Console.WriteLine($"Event ontvangen: {boodschap}"); } public static void Main() { EventVoorbeeld voorbeeld = new EventVoorbeeld(); voorbeeld.MijnEvent += EventHandler; voorbeeld.ActiveerEvent(); } } Event ontvangen: Event geactiveerd! ✅ Hier registreren we EventHandler() als subscriber voor MijnEvent. ✅ Wanneer ActiveerEvent() wordt aangeroepen, wordt EventHandler() uitgevoerd.✅ Een event kan meerdere subscribers hebben, waardoor meerdere methoden tegelijk worden uitgevoerd.public class Program { public static void Methode1(string boodschap) { Console.WriteLine($"Methode1 zegt: {boodschap}"); } public static void Methode2(string boodschap) { Console.WriteLine($"Methode2 zegt: {boodschap}"); } public static void Main() { EventVoorbeeld voorbeeld = new EventVoorbeeld(); voorbeeld.MijnEvent += Methode1; voorbeeld.MijnEvent += Methode2; voorbeeld.ActiveerEvent(); } } Methode1 zegt: Event geactiveerd! Methode2 zegt: Event geactiveerd! ✅ Hier reageren zowel Methode1() als Methode2() op hetzelfde event.✅ Events worden vaak gebruikt in GUI-programma’s om gebruikersinteracties te verwerken.public class Button { public event EventHandler Click; public void Klik() { Click?.Invoke(this, EventArgs.Empty); } } public class Program { public static void ButtonKlikHandler(object sender, EventArgs e) { Console.WriteLine("De knop is ingedrukt!"); } public static void Main() { Button knop = new Button(); knop.Click += ButtonKlikHandler; knop.Klik(); } } De knop is ingedrukt! ✅ Hier wordt een event geactiveerd wanneer een knop wordt ingedrukt. ✅ Dit is een veelgebruikte techniek in Windows Forms en WPF-applicaties.✅ Events maken het mogelijk om een actie te laten plaatsvinden wanneer een bepaalde gebeurtenis optreedt. ✅ Events volgen het publisher/subscriber-patroon. ✅ Gebruik event om een event te definiëren en += om een subscriber toe te voegen. ✅ Events kunnen meerdere subscribers hebben, waardoor meerdere methoden tegelijk worden uitgevoerd. ✅ Events worden vaak gebruikt in GUI-programma’s om gebruikersinteracties te verwerken.

8.5 - Delegates

Fri, 20 Jun 2025 09:30:56 GMT

Een delegate is een type dat een verwijzing naar een methode kan opslaan.✅ Wat is een delegate? Een delegate fungeert als een pointer naar een methode. Hiermee kun je methoden dynamisch aanroepen zonder ze expliciet te definiëren. Delegates worden vaak gebruikt in event-driven programmeren en callback-methoden. ✅ Voordelen van delegates: Flexibiliteit → Je kunt methoden dynamisch koppelen en aanroepen. Losse koppeling → Code wordt minder afhankelijk van specifieke methoden. Event-driven programmeren → Delegates worden vaak gebruikt in event handlers. Multicast delegates → Eén delegate kan meerdere methoden tegelijk aanroepen. ✅ Gebruik het delegate keyword om een delegate te definiëren.public delegate void MijnDelegate(string boodschap); ✅ Hier definiëren we een delegate MijnDelegate die een methode kan opslaan die een string als parameter accepteert.✅ Een delegate kan een methode oproepen die overeenkomt met de gespecificeerde parameters en return type.public class Program { public static void ToonBericht(string boodschap) { Console.WriteLine(boodschap); } public static void Main() { MijnDelegate del = new MijnDelegate(ToonBericht); del("Hallo, dit is een delegate!"); } } Hallo, dit is een delegate! ✅ Hier koppelen we ToonBericht() aan de delegate MijnDelegate en roepen deze dynamisch aan.✅ Een delegate kan meerdere methoden tegelijk aanroepen.public delegate void MijnDelegate(string boodschap); public class Program { public static void Methode1(string boodschap) { Console.WriteLine($"Methode1 zegt: {boodschap}"); } public static void Methode2(string boodschap) { Console.WriteLine($"Methode2 zegt: {boodschap}"); } public static void Main() { MijnDelegate del = Methode1; del += Methode2; del("Hallo, multicast delegate!"); } } Methode1 zegt: Hallo, multicast delegate! Methode2 zegt: Hallo, multicast delegate! ✅ Hier roepen we zowel Methode1() als Methode2() aan met dezelfde delegate.✅ Delegates worden vaak gebruikt in event-driven programmeren.public delegate void MijnEventHandler(string boodschap); public class EventVoorbeeld { public event MijnEventHandler MijnEvent; public void ActiveerEvent() { if (MijnEvent != null) { MijnEvent("Event geactiveerd!"); } } } public class Program { public static void EventHandler(string boodschap) { Console.WriteLine($"Event ontvangen: {boodschap}"); } public static void Main() { EventVoorbeeld voorbeeld = new EventVoorbeeld(); voorbeeld.MijnEvent += EventHandler; voorbeeld.ActiveerEvent(); } } Event ontvangen: Event geactiveerd! ✅ Hier gebruiken we een delegate als event-handler om een gebeurtenis dynamisch af te handelen.✅ Delegates fungeren als pointers naar methoden en maken dynamische aanroepen mogelijk. ✅ Gebruik delegate om een delegate te definiëren. ✅ Delegates kunnen meerdere methoden tegelijk aanroepen (multicast delegates). ✅ Delegates worden vaak gebruikt in event-driven programmeren. ✅ Events gebruiken delegates om dynamisch methoden aan te roepen bij een gebeurtenis.

8.4 - Enum

Fri, 20 Jun 2025 09:23:38 GMT

Enum is de afkorting van enumeration, wat betekent opsomming.Een enum is een speciaal type klasse in C# dat wordt gebruikt om een set van constante waarden te definiëren.✅ Kenmerken van een enum: Een enum bevat een vaste lijst van waarden. Een enum kan worden gebruikt om een opsomming van keuzes te maken (zoals dagen van de week, kleuren, statussen). Je kunt geen objecten van een enum maken. De waarden in een enum zijn integer-gebaseerd, beginnend vanaf 0 (tenzij anders gespecificeerd). ✅ Voordelen van enums: Verbeteren leesbaarheid en onderhoudbaarheid van code → Vermijd het gebruik van losse strings of getallen. Voorkomen fouten → Voorkomen dat ongeldige waarden worden gebruikt. Vergemakkelijken switch-statements en logica → Werkt beter dan losse string-vergelijkingen. Vergroten typeveiligheid → Enum-waarden kunnen niet per ongeluk veranderen zoals een string. ✅ Gebruik enum om een vaste lijst van mogelijke waarden te definiëren.public enum Kleur { Zwart, Wit, Rood, Blauw, Paars } ✅ Hier definiëren we een vaste lijst van kleuren die gebruikt kunnen worden. ✅ De waarden worden intern als integers opgeslagen (beginnend bij 0 tenzij anders aangegeven).✅ Een enum kan worden gebruikt als eigenschap binnen een klasse.public class Stadsauto { private Kleur kleur; public int AantalDeuren { get; set; } public Stadsauto(Kleur kleur, int aantalDeuren) { this.kleur = kleur; AantalDeuren = aantalDeuren; } public void ToonDetails() { Console.WriteLine($"Deze stadsauto heeft {AantalDeuren} deuren en is {kleur}."); } } ✅ Hier gebruiken we Kleur als type voor een eigenschap in Stadsauto. ✅ Het voorkomt dat een kleur als willekeurige string wordt ingevoerd, waardoor typeveiligheid wordt gegarandeerd.✅ Wanneer je een enum-waarde gebruikt, moet je eerst de naam van de enum schrijven, gevolgd door een punt en de waarde.Stadsauto auto = new Stadsauto(Kleur.Zwart, 4); auto.ToonDetails(); ✅ Hier geven we Kleur.Zwart mee als parameter in de constructor.Deze stadsauto heeft 4 deuren en is Zwart. ✅ Standaard beginnen enum-waarden bij 0 en tellen automatisch op, maar je kunt ze handmatig instellen.public enum Status { Inactief = 0, Actief = 1, Verlopen = 99 } ✅ Hier krijgt Inactief de waarde 0, Actief de waarde 1 en Verlopen de waarde 99.✅ Je kunt een enum-waarde omzetten naar een integer.int code = (int)Status.Actief; Console.WriteLine($"De statuscode voor Actief is {code}"); De statuscode voor Actief is 1 ✅ Hier wordt Status.Actief omgezet naar het bijbehorende getal (1).✅ Enums werken goed met een switch-statement, waardoor je verschillende acties kunt uitvoeren afhankelijk van de waarde.Status huidigeStatus = Status.Actief; switch (huidigeStatus) { case Status.Inactief: Console.WriteLine("Dit item is inactief."); break; case Status.Actief: Console.WriteLine("Dit item is actief."); break; case Status.Verlopen: Console.WriteLine("Dit item is verlopen."); break; } ✅ Hier gebruiken we switch om de juiste actie te kiezen op basis van de huidige status.✅ Een enum is een opsomming van vooraf gedefinieerde constante waarden. ✅ Enums verbeteren leesbaarheid, typeveiligheid en onderhoudbaarheid. ✅ Je kunt een enum gebruiken binnen een klasse om een eigenschap te definiëren. ✅ Enums beginnen standaard bij 0, maar je kunt handmatig waarden toewijzen. ✅ Je kunt een enum-waarde naar een int converteren en een switch gebruiken om verschillende acties uit te voeren.

8.3 - Generics

Fri, 20 Jun 2025 09:22:45 GMT

Een belangrijk concept binnen moderne C#-ontwikkeling is generics.✅ Wat zijn generics? Generics maken het mogelijk om flexibele en herbruikbare code te schrijven. In plaats van een specifiek datatype te definiëren, gebruik je een placeholder (T). Hierdoor kan een klasse, methode of interface werken met elk datatype zonder code te dupliceren. ✅ Voordelen van generics: Voorkomen duplicatie van code → Schrijf één methode die werkt met verschillende datatypes. Verbeteren flexibiliteit → Methoden en klassen worden niet beperkt tot één specifiek datatype. Verhogen typeveiligheid → Voorkomen onverwachte fouten door sterk getypeerde generieke parameters. Verbeteren prestaties → Geen onnodige type-conversies en minder geheugenallocaties. ✅ Je kunt een generieke methode maken die met verschillende datatypes werkt.public class Helper { public static void Toon(T waarde) { Console.WriteLine($"De waarde is: {waarde}"); } } Helper.Toon(42); // Werkt met int Helper.Toon("Hallo!"); // Werkt met string Helper.Toon(3.14); // Werkt met double ✅ Hier gebruiken we T als een placeholder voor een datatype. ✅ De compiler bepaalt automatisch het juiste datatype gebaseerd op de invoer.✅ Je kunt generieke klassen maken die werken met elk type data.public class Opslag { private T waarde; public void ZetWaarde(T nieuweWaarde) { waarde = nieuweWaarde; } public T HaalWaardeOp() { return waarde; } } Opslag getalOpslag = new Opslag(); getalOpslag.ZetWaarde(42); Console.WriteLine(getalOpslag.HaalWaardeOp()); // Output: 42 Opslag tekstOpslag = new Opslag(); tekstOpslag.ZetWaarde("Hallo!"); Console.WriteLine(tekstOpslag.HaalWaardeOp()); // Output: Hallo! ✅ Hier werken Opslag en Opslag met verschillende datatypes zonder extra code. ✅ De generieke klasse Opslag kan elk type opslaan, zonder dat we aparte klassen hoeven te maken.✅ Net zoals klassen en methoden, kunnen interfaces ook generiek zijn!public interface IRepo { void VoegToe(T item); T HaalOp(int id); } public class ProductRepo : IRepo { private List producten = new List(); public void VoegToe(string item) { producten.Add(item); } public string HaalOp(int id) { return producten[id]; } } IRepo repo = new ProductRepo(); repo.VoegToe("Laptop"); Console.WriteLine(repo.HaalOp(0)); // Output: Laptop ✅ Hier zorgen generieke interfaces ervoor dat we flexibel objecten kunnen beheren. ✅ Elke klasse kan een interface implementeren met een eigen datatype.✅ Soms wil je generieke typen beperken tot bepaalde klassen.Voorbeeld: Je wilt dat een generiek type altijd een klasse is en niet een primitief datatype.public class WerkMetKlasse where T : class { public T Object { get; set; } public void ToonType() { Console.WriteLine($"Dit object is van type: {typeof(T)}"); } } WerkMetKlasse tekst = new WerkMetKlasse(); tekst.ToonType(); // Output: Dit object is van type: System.String ✅ Hier garanderen we dat T een klasse moet zijn (where T : class). ✅ Dit voorkomt dat we bijvoorbeeld een int proberen te gebruiken als generiek type.✅ Generics maken het mogelijk om flexibele en herbruikbare code te schrijven. ✅ Je kunt generieke methoden, klassen en interfaces maken die met elk datatype werken. ✅ Door generics te gebruiken, voorkom je duplicatie en verhoog je typeveiligheid. ✅ Constraints helpen om generieke types te beperken tot specifieke typen.

8.2 - Interfaces

Fri, 20 Jun 2025 09:20:48 GMT

Een belangrijk concept binnen overerving zijn de interfaces.Een interface kun je zien als een volledig abstracte klasse, waarin abstracte methoden en properties staan.✅ Wat is een interface? Een contract dat een klasse moet volgen. Een verzameling methoden en properties zonder implementatie. Een klasse die een interface implementeert, is verplicht alle methoden en properties ervan te gebruiken. Belangrijk: Een klasse implementeert een interface, maar erft deze niet! ✅ Een interface kan geen constructor bevatten en er kunnen geen objecten van worden gemaakt. ✅ Een interface kan alleen methoden en properties bevatten, geen variabelen of constanten. ✅ Alle methoden en properties in een interface zijn standaard public en abstract en bevatten geen body. ✅ Een klasse die een interface implementeert, is verplicht alle methoden en properties te implementeren. ✅ Een klasse kan slechts één parentklasse hebben, maar kan wel meerdere interfaces tegelijk implementeren. ✅ Interfaces beginnen vaak met een I (bijvoorbeeld IScalable) om ze te onderscheiden van gewone klassen. ✅ Interfaces hebben vaak een -able naam in het Engels (Scalable, Movable, Changeable, etc.) om hun doel te verduidelijken.✅ Interfaces maken het mogelijk dat totaal verschillende objecten toch hetzelfde gedrag vertonen zonder dat ze dezelfde parentklasse hebben. ✅ Interfaces zorgen voor totale abstractie → De klasse die de interface implementeert moet alle methoden en properties gebruiken. ✅ Interfaces lossen het probleem van enkele overerving op → Een klasse kan slechts één parentklasse hebben, maar wel meerdere interfaces implementeren.Het maken van een interface werkt hetzelfde als het maken van een klasse.public interface IScalable { void Schaal(int factor); } ✅ Hier definiëren we een methode Schaal() zonder body. ✅ Elke klasse die IScalable implementeert, is verplicht Schaal() te implementeren.✅ Een interface implementeren werkt net als overerving, maar met : in de class-definitie.public class Vierkant : IScalable { public void Schaal(int factor) { Console.WriteLine($"Vierkant schalen met factor {factor}"); } } IScalable vorm = new Vierkant(); vorm.Schaal(2); // Output: Vierkant schalen met factor 2 ✅ Hier behandelen we Vierkant als een IScalable, zonder te weten dat het specifiek een vierkant is!✅ Een klasse kan meerdere interfaces tegelijk implementeren, gescheiden door een komma.public interface IMoveable { void Beweeg(int x, int y); } public class Vierkant : IScalable, IMoveable { public void Schaal(int factor) { Console.WriteLine($"Vierkant schalen met factor {factor}"); } public void Beweeg(int x, int y) { Console.WriteLine($"Vierkant bewegen naar positie ({x}, {y})"); } } IMoveable object1 = new Vierkant(); IScalable object2 = new Vierkant(); object1.Beweeg(10, 20); object2.Schaal(3); ✅ Hier kan Vierkant als zowel IMoveable als IScalable worden behandeld!✅ Gebruik een interface als je een contract wilt definiëren dat door verschillende klassen moet worden gevolgd. ✅ Gebruik een abstracte klasse als je een gedeeltelijke implementatie wilt geven naast abstracte methoden.✅ Een interface is een volledig abstracte klasse zonder implementatie. ✅ Interfaces bevatten methoden en properties, maar geen variabelen of constanten. ✅ Een klasse kan meerdere interfaces tegelijk implementeren. ✅ Interfaces zorgen voor totale abstractie, en de implementerende klasse moet alle methoden gebruiken. ✅ Gebruik een interface als je een contract wilt definiëren dat verschillende klassen kunnen volgen.In de volgende paragraaf behandelen we generics, waarmee we flexibelere en herbruikbare code kunnen schrijven!

7.3 - Abstracte klassen en methoden

Fri, 20 Jun 2025 09:17:43 GMT

We kunnen ondertussen al werken met overerving.Een belangrijk concept binnen overerving is het keyword abstract.✅ Wat doet abstract? Een abstracte klasse kan niet direct worden geïnstantieerd. Childklassen kunnen ervan overerven, maar er kunnen geen objecten van worden gemaakt. Abstracte methoden moeten verplicht worden geïmplementeerd in childklassen. Soms heb je een klasse die te abstract is om er directe objecten van te maken.✅ Voorbeeld: Wiskundige figuren Een geometrisch figuur is een te breed begrip. Maar een cirkel, rechthoek of kubus zijn concrete childklassen. Door abstract te gebruiken, kunnen we de basisstructuur van een figuur definiëren zonder objecten van de parentklasse te maken.class GeometrischFiguur { public int Lengte { get; set; } public int Breedte { get; set; } } class Vierkant : GeometrischFiguur { } // Dit werkt, maar je kunt nu een object van `GeometrischFiguur` maken. GeometrischFiguur figuur = new GeometrischFiguur(); // Dit mag, maar is onlogisch. ✅ Hier kunnen we objecten maken van zowel GeometrischFiguur als Vierkant. ✅ Maar dit is niet logisch, want een GeometrischFiguur is te abstract.✅ Gebruik abstract in de parentklasse om te voorkomen dat er objecten van worden gemaakt.abstract class GeometrischFiguur { public int Lengte { get; set; } public int Breedte { get; set; } } class Vierkant : GeometrischFiguur { } // Dit zal een fout geven: GeometrischFiguur figuur = new GeometrischFiguur(); // ERROR: Kan geen object maken! ✅ Hier kan GeometrischFiguur alleen als parentklasse worden gebruikt. ✅ Je kunt er geen objecten van maken, maar wel van childklassen zoals Vierkant.Abstracte methoden kunnen alleen in abstracte klassen bestaan!✅ Wat doet een abstracte methode? Heeft geen body in de parentklasse. Moet verplicht worden geïmplementeerd in elke childklasse. Wordt overschreven met override in de childklasse. abstract class GeometrischFiguur { public abstract string Naam(); // Geen body! } class Vierkant : GeometrischFiguur { public override string Naam() { return "Ik ben een vierkant!"; } } Vierkant vierkant = new Vierkant(); Console.WriteLine(vierkant.Naam()); // Output: Ik ben een vierkant! ✅ Hier moet elke childklasse verplicht Naam() implementeren! ✅ De parentklasse geeft de structuur, maar de childklasse bepaalt de implementatie.Net zoals methoden kunnen properties ook abstract zijn!abstract class Dier { public abstract string Geluid { get; } } class Hond : Dier { public override string Geluid { get { return "Woef!"; } } } class Kat : Dier { public override string Geluid { get { return "Miauw!"; } } } Hond hond = new Hond(); Kat kat = new Kat(); Console.WriteLine(hond.Geluid); // Output: Woef! Console.WriteLine(kat.Geluid); // Output: Miauw! ✅ Elke childklasse moet verplicht de Geluid-property implementeren! ✅ De parentklasse geeft alleen de structuur, maar niet de inhoud.✅ Abstracte klassen kunnen niet direct worden geïnstantieerd. ✅ Gebruik abstract om een klasse puur als parentklasse te definiëren. ✅ Abstracte methoden hebben geen body en moeten verplicht geïmplementeerd worden in childklassen. ✅ Gebruik override in de childklasse om de abstracte methode te implementeren. ✅ Abstracte properties werken hetzelfde als abstracte methoden.

6.3 - Foreach-loop

Fri, 20 Jun 2025 09:13:10 GMT

We weten ondertussen al hoe we met loops kunnen werken.Speciaal voor arrays is er een nieuwe loop in het leven geroepen: de foreach-loop.✅ Wat is een foreach-loop? Een compactere versie van de for-loop. Speciaal ontworpen voor arrays en collecties. Automatisch door alle elementen itereren zonder handmatige indexering. ✅ Voordelen van een foreach-loop: Kortere en overzichtelijkere code. Geen handmatige indexering nodig. Automatisch door alle elementen itereren. ❌ Nadelen van een foreach-loop: Je kunt geen specifieke indexpositie aanpassen. Je kunt geen bepaalde range aangeven (zoals i = 2 tot i = 5). Om dit duidelijk te maken, gaan we eerst een array als voorbeeld aanmaken:int[] cijfers = {8, 12, 502, 6}; for (int i = 0; i < cijfers.Length; i++) { Console.WriteLine(cijfers[i]); } ✅ Hier gebruiken we .Length om de totale lengte van de array te bepalen. ✅ Bij elke iteratie wordt de waarde van cijfers[i] geprint. ✅ Handig als je een specifieke range wilt doorlopen.foreach (int cijfer in cijfers) { Console.WriteLine(cijfer); } ✅ Hier hoeven we geen index (i) te gebruiken. ✅ De loop doorloopt automatisch alle elementen. ✅ Handig als je alle waarden wilt verwerken zonder specifieke indexering.Binnen C# is er een handige feature wanneer je met een foreach-loop werkt: het datatype var.✅ Wat doet var? Laat de compiler automatisch het datatype bepalen. Vermijdt typefouten. Maakt de code korter en leesbaarder. foreach (var cijfer in cijfers) { Console.WriteLine(cijfer); } ✅ Hier hoeft het datatype (int) niet expliciet te worden vermeld. ✅ De compiler bepaalt automatisch dat cijfer een int is.Meer uitleg over var in loops vind je op Microsoft Learn.✅ Gebruik een foreach-loop als: Je alle elementen in een array wilt doorlopen. Je geen specifieke indexpositie hoeft te wijzigen. Je een kortere en overzichtelijke loop wilt schrijven. ❌ Gebruik een for-loop als: Je een specifieke range wilt doorlopen (i = 2 tot i = 5). Je een element op een bepaalde index wilt wijzigen. ✅ Foreach-loops zijn korter en overzichtelijker dan for-loops. ✅ Je hoeft geen handmatige indexering te gebruiken. ✅ Gebruik var om automatisch het datatype te laten bepalen. ✅ Gebruik een for-loop als je een specifieke index wilt aanpassen. ✅ Gebruik een foreach-loop als je alle elementen wilt doorlopen zonder wijzigingen.

5.8 - Var

Fri, 20 Jun 2025 09:08:11 GMT

Het var-keyword in C# maakt het mogelijk om lokale variabelen te declareren zonder expliciet een datatype op te geven.✅ Wat doet var? Laat de compiler automatisch het datatype bepalen op basis van de initiële waarde. Maakt code korter en leesbaarder. Kan alleen worden gebruikt voor lokale variabelen binnen methoden. ✅ Voordelen van var: Minder typwerk → Je hoeft het datatype niet expliciet te schrijven. Verbeterde leesbaarheid → Vooral handig bij lange en complexe typen. Sterke typecontrole → De variabele blijft sterk getypeerd, ondanks dat het type impliciet wordt bepaald. ✅ Gebruik var om een variabele te declareren zonder expliciet een datatype op te geven.var naam = "Alice"; // Compiler bepaalt dat dit een string is var leeftijd = 25; // Compiler bepaalt dat dit een int is var prijs = 19.99m; // Compiler bepaalt dat dit een decimal is Console.WriteLine($"Naam: {naam}, Leeftijd: {leeftijd}, Prijs: {prijs}"); Naam: Alice, Leeftijd: 25, Prijs: 19.99 ✅ Hier bepaalt de compiler automatisch het juiste datatype op basis van de initiële waarde.✅ var is handig bij lange en complexe typen, zoals generieke collecties (zie hoofdstuk 8).var namen = new List { "Alice", "Bob", "Charlie" }; foreach (var naam in namen) { Console.WriteLine(naam); } ✅ Hier voorkomt var dat we List expliciet moeten schrijven.✅ Bij anonieme typen is var verplicht, omdat het type niet expliciet kan worden opgegeven.var persoon = new { Naam = "Alice", Leeftijd = 25 }; Console.WriteLine($"Naam: {persoon.Naam}, Leeftijd: {persoon.Leeftijd}"); ✅ Hier maakt var het mogelijk om een object te gebruiken zonder een expliciete klasse te definiëren.❌ Kan niet worden gebruikt voor velden in een klasse → Alleen binnen methoden. ❌ Kan niet worden gebruikt zonder een initiële waarde → De compiler moet het type kunnen afleiden. ❌ Kan niet worden gebruikt als een variabele meerdere typen moet bevatten → var is niet hetzelfde als dynamic.var x; // FOUT! Compiler kan het type niet bepalen ✅ Gebruik var als: Het type duidelijk is uit de initiële waarde. Je lange en complexe typen wilt vermijden. Je werkt met anonieme typen. ❌ Gebruik var niet als: Het type niet duidelijk is uit de initiële waarde. Je expliciete typecontrole nodig hebt. ✅ var maakt het mogelijk om variabelen te declareren zonder expliciet een datatype op te geven. ✅ De compiler bepaalt automatisch het juiste type op basis van de initiële waarde. ✅ var is handig bij lange en complexe typen, zoals generieke collecties. ✅ Bij anonieme typen is var verplicht. ✅ Gebruik var alleen als het type duidelijk is uit de initiële waarde.

5.7 - Static

Fri, 20 Jun 2025 09:05:41 GMT

We zijn het keyword static ondertussen al een paar keer tegengekomen. Denk hierbij aan static methoden, zoals beschreven in paragraaf 5.6.Het is een belangrijk concept dat extra uitleg nodig heeft!We maken een onderscheid tussen: ✅ Static variabelen → Gedeeld tussen alle objecten van een klasse. ✅ Static methoden → Kunnen worden aangeroepen zonder een object te maken. ✅ Static klassen → Kunnen geen objecten hebben en bevatten alleen static members.De letterlijke vertaling van static is statisch, maar een betere vertaling is gedeeld.Wanneer je meerdere objecten van een klasse maakt, zal een static variabele gedeeld worden tussen alle objecten. Belangrijk: Als je de waarde van een static variabele wijzigt in één object, wordt deze automatisch aangepast voor alle objecten van die klasse! Dit komt omdat de compiler de statische variabelen, methoden en klassen slechts één keer in het geheugen van de computer zet.✅ Static variabelen en methoden horen bij de klasse zelf, niet bij individuele objecten. ✅ Alle objecten van een klasse delen dezelfde static variabelen en methoden.Normaal gesproken heeft elk object zijn eigen versie van een variabele.class Mens { private int leeftijd = 1; public int Leeftijd { get { return leeftijd; } set { leeftijd = value; } } public void Jarig() { Leeftijd++; } } Mens m1 = new Mens(); Mens m2 = new Mens(); m1.Jarig(); m1.Jarig(); m2.Jarig(); Console.WriteLine($"{m1.Leeftijd}"); // Output: 3 Console.WriteLine($"{m2.Leeftijd}"); // Output: 2 Hier heeft elk object zijn eigen versie van leeftijd.Als we leeftijd static maken, delen alle objecten dezelfde waarde.class Mens { private static int leeftijd = 1; public int Leeftijd { get { return leeftijd; } set { leeftijd = value; } } public void Jarig() { Leeftijd++; } } Mens m1 = new Mens(); Mens m2 = new Mens(); m1.Jarig(); m1.Jarig(); m2.Jarig(); Console.WriteLine($"{m1.Leeftijd}"); // Output: 4 Console.WriteLine($"{m2.Leeftijd}"); // Output: 4 ✅ Alle objecten delen dezelfde variabele. ✅ Wijzigingen in één object beïnvloeden alle andere objecten.Ook methoden kunnen static zijn.Je bent dit al tegengekomen bij de Math-klasse.double x = Math.Pow(3, 2); // Dit werkt zonder een object! Dat komt omdat alle methoden in Math static zijn!public static class Rekenmachine { public static int Optellen(int a, int b) { return a + b; } } int resultaat = Rekenmachine.Optellen(5, 3); Console.WriteLine($"De som is: {resultaat}"); ✅ Je hoeft geen object te maken om de methode te gebruiken.Meer uitleg over static methoden vind je op Microsoft Learn.Een static klasse kan geen objecten hebben.✅ Alle methoden en variabelen in een static klasse moeten static zijn. ✅ Je kunt een static klasse niet erven.static class Helper { public static void ToonBericht() { Console.WriteLine("Dit is een static klasse!"); } } Helper.ToonBericht(); // Werkt zonder object! ✅ Static variabelen → Gedeeld tussen alle objecten van een klasse. ✅ Static methoden → Kunnen worden aangeroepen zonder een object te maken. ✅ Static klassen → Kunnen geen objecten hebben en bevatten alleen static members. ✅ Gebruik static voor gedeelde functionaliteit zoals helper-methoden en configuratie.

5.6 - Methoden

Fri, 20 Jun 2025 09:02:26 GMT

Een methode is een codeblok dat alleen wordt uitgevoerd als je het via een object (of via een andere methode) oproept.Je kunt een methode zien als functionaliteit van een object. Zonder methoden kun je geen echte objectgeoriënteerde applicatie schrijven.Methoden kunnen namelijk de eigenschappen van een object aanpassen en zorgen ervoor dat een object interactief kan zijn.We gaan in deze paragraaf verder met onze klasse Auto en breiden deze uit met enkele methoden.Methoden bestaan uit: ✅ Een access modifier (public, private, protected) ✅ Een return type (void, int, string, etc.) ✅ Een naam (bijvoorbeeld Versnel(), Stop()) ✅ Optionele parameters (invoerwaarden) ✅ Een codeblok met instructiespublic void VeranderKleur(string nieuweKleur) { kleur = nieuweKleur; } ✅ public → De methode mag buiten deze klasse worden aangeroepen. ✅ void → De methode geeft geen waarde terug, maar wijzigt een eigenschap. ✅ Parameter (string nieuweKleur) → De nieuwe kleur wordt meegegeven als invoer.Gebruik van de methode:Auto mijnAuto = new Auto("BMW", 4, "Blauw"); mijnAuto.VeranderKleur("Rood"); // Kleur wijzigen Console.WriteLine($"De auto heeft nu de kleur {mijnAuto.Kleur}."); public double HoeveelBrandstofVerbruikt() { verbruik = MAX_TANKINHOUD - huidigeTankinhoud; return verbruik; } ✅ Geen void, maar double → De methode moet een waarde teruggeven. ✅ Keyword return → De methode geeft het resultaat van de berekening terug.Gebruik van de methode:double verbruik = mijnAuto.HoeveelBrandstofVerbruikt(); Console.WriteLine($"De auto heeft {verbruik} liter brandstof verbruikt."); Een void-methode voert een actie uit maar geeft geen waarde terug.Dit betekent dat je geen return mag gebruiken in een void-methode.Een static-methode kan worden aangeroepen zonder een object van de klasse te maken.public static void ToonTekst() { Console.WriteLine("Dit is een statische methode!"); } Gebruik zonder object:Auto.ToonTekst(); Meer uitleg over static-methoden vind je op Microsoft Docs.Je kunt methoden in elkaar laten overlopen door ze in een andere methode aan te roepen.void SchrijfA() { Console.WriteLine("A"); } void SchrijfB() { Console.WriteLine("B"); } void SchrijfC() { Console.WriteLine("C"); } void SchrijfLetters() { SchrijfA(); SchrijfB(); SchrijfC(); } Hier roept SchrijfLetters() de methoden SchrijfA(), SchrijfB() en SchrijfC() aan.Meer uitleg over method chaining vind je op Stack Overflow.Method overloading betekent dat je meerdere methoden met dezelfde naam kunt hebben, zolang ze verschillende parameters hebben.Dit is handig wanneer je een actie wilt uitvoeren met verschillende soorten invoer.✅ Maakt code overzichtelijker → Je hoeft geen verschillende methoden met unieke namen te bedenken. ✅ Verhoogt flexibiliteit → Je kunt dezelfde methode gebruiken voor verschillende soorten invoer. ✅ Ondersteunt polymorfisme → Dit is een fundamenteel concept van OOP.Je kunt method overloading toepassen door: ✅ Het aantal parameters te wijzigen ✅ De datatypes van parameters te wijzigen ✅ De volgorde van parameters te wijzigenclass Rekenmachine { public int Optellen(int a, int b) { return a + b; } public int Optellen(int a, int b, int c) { return a + b + c; } } Gebruik:Rekenmachine calc = new Rekenmachine(); Console.WriteLine(calc.Optellen(5, 3)); // Output: 8 Console.WriteLine(calc.Optellen(5, 3, 2)); // Output: 10 class Rekenmachine { public int Optellen(int a, int b) { return a + b; } public double Optellen(double a, double b) { return a + b; } } Gebruik:Console.WriteLine(calc.Optellen(5, 3)); // Output: 8 (int) Console.WriteLine(calc.Optellen(5.5, 3.2)); // Output: 8.7 (double) ✅ Methoden voegen functionaliteit toe aan objecten. ✅ Void-methoden → Voeren een actie uit, maar geven geen waarde terug. ✅ Return-methoden → Geven een waarde terug. ✅ Static-methoden → Kunnen worden aangeroepen zonder object. ✅ Method chaining → Methoden kunnen andere methoden oproepen. ✅ Method overloading → Meerdere methoden met dezelfde naam, maar verschillende parameters.

5.5 - Properties

Fri, 20 Jun 2025 09:01:51 GMT

In de vorige paragrafen hebben we geleerd dat we binnen klassen zoveel mogelijk de access modifier private moeten gebruiken. Dit principe, inkapseling, is een belangrijk onderdeel van Object-Oriented Programming (OOP), omdat het veiligheid en controle garandeert.Maar als variabelen private zijn, hoe kunnen we deze dan toch benaderen? Dat is waar properties hun entree maken!Properties bieden een veilige manier om variabelen op te vragen en te wijzigen zonder direct toegang tot de interne data van een object te geven.Andere programmeertalen, zoals Java, werken met getter en setter methoden. C# heeft dit systeem verbeterd en geautomatiseerd door properties te introduceren.Kort gezegd: ✅ Properties zijn een gecontroleerde manier om private variabelen te lezen en te wijzigen. ✅ Ze bieden een veiliger alternatief voor directe variabeletoegang. ✅ Ze ondersteunen inkapseling zonder extra methoden zoals get() en set() in Java.C# kent twee soorten properties: ✅ Autoproperties → Weinig code, maar beperkte controle. ✅ Full properties → Meer controle over wat er gebeurt.Een full property geeft volledige controle over wat er gebeurt wanneer een variabele wordt opgevraagd of gewijzigd.private int aantalDeuren = 5; public int AantalDeuren { get { return aantalDeuren; // Geeft de waarde terug } set { if (value > 0) // Alleen toestaan als waarde > 0 { aantalDeuren = value; } } } Hier gebeurt het volgende: ✅ Getter → Haalt de huidige waarde van aantalDeuren op. ✅ Setter → Wijzigt aantalDeuren, maar alleen als de waarde > 0 is.Zo zorgen we ervoor dat geen invalid values (zoals -5 deuren) worden toegelaten.Meer uitleg over full properties vind je op Microsoft Learn.Een autoproperty is een snelle, compacte versie van een full property.public int AantalDeuren { get; set; } Belangrijk: Autoproperties kunnen niet aangepast worden met extra logica zoals validatie (if-statements). Voor een readonly property, gebruik:public int AantalDeuren { get; } Voor een write-only property, gebruik:public int AantalDeuren { set; } Je kunt properties flexibel aanpassen met verschillende varianten:Een property die alleen kan worden gewijzigd maar niet opgevraagd.public int AantalDeuren { set { aantalDeuren = value; } } Gebruik: Bijvoorbeeld bij beveiligde gegevens, zoals wachtwoorden. Een property die alleen kan worden opgevraagd maar niet gewijzigd.public int AantalDeuren { get { return aantalDeuren; } } Gebruik: Bijvoorbeeld bij constante waarden die nooit mogen veranderen. Een property die alleen vanuit de klasse zelf gewijzigd mag worden.public int AantalDeuren { get { return aantalDeuren; } private set { aantalDeuren = value; } } Gebruik: Bijvoorbeeld bij automatisch gegenereerde waarden die niet door de gebruiker mogen worden aangepast. Het is best practice om altijd de property te gebruiken in plaats van de directe variabele.void VerhoogAantalDeuren() { aantalDeuren++; // DIRECTE variabeletoegang (niet aanbevolen) } void VerhoogAantalDeuren() { AantalDeuren++; // Gebruik de property (wel aanbevolen) } ✅ Voordeel: Zo blijven alle validatieregels in de property actief!✅ Properties vervangen getters en setters uit andere talen zoals Java. ✅ Autoproperties → Snelle en compacte oplossing zonder extra logica. ✅ Full properties → Volledige controle, inclusief validatie en checks. ✅ Write-only, Read-only en Mixed properties → Extra flexibiliteit. ✅ Gebruik altijd de property in methoden in plaats van de directe variabele.In de volgende paragraaf behandelen we methoden, waarmee je objecten kunt laten uitvoeren wat ze moeten doen!

5.4 - Access modifiers

Fri, 20 Jun 2025 08:54:29 GMT

In de vorige paragrafen hebben we geleerd hoe we klassen kunnen maken en van die klassen objecten kunnen creëren. We hebben ook geleerd over class members (variabelen en constanten die tot een klasse behoren).Nu komen we bij een belangrijk concept in Object-Oriented Programming (OOP): inkapseling.Inkapseling garandeert dat data niet onbedoeld toegankelijk is en wordt beschermd tegen ongewenste wijzigingen. Dit wordt geregeld door access modifiers.Access modifiers bepalen welke delen van je code toegang hebben tot variabelen, methoden en klassen.C# kent vier belangrijke access modifiers:✅ public → Iedereen heeft toegang. ✅ private → Alleen toegankelijk binnen dezelfde klasse. ✅ protected → Alleen toegankelijk binnen de klasse en subklassen (bij overerving). ✅ internal → Alleen toegankelijk binnen hetzelfde project.Meer uitleg over access modifiers vind je op Microsoft Learn.public betekent dat iedereen toegang heeft.public class Auto { public string Merk; public void ToonMerk() { Console.WriteLine($"Merk: {Merk}"); } } Auto mijnAuto = new Auto(); mijnAuto.Merk = "Tesla"; mijnAuto.ToonMerk(); // Iedereen kan deze methode aanroepen! Let op: Public variabelen zijn kwetsbaar en kunnen overal gewijzigd worden. > Tip: Gebruik properties in plaats van public variabelen! private betekent dat alleen de klasse zelf toegang heeft.public class Auto { private string Merk; // Merk is privé public void ZetMerk(string nieuwMerk) { Merk = nieuwMerk; // Alleen toegankelijk binnen deze klasse } } Auto mijnAuto = new Auto(); mijnAuto.ZetMerk("BMW"); // We kunnen Merk alleen via deze methode wijzigen! Waarom private gebruiken? ✅ Voorkomt ongewenste wijzigingen van buitenaf. ✅ Dwingt veilige toegang via methoden of properties. protected betekent dat een klasse en subklassen toegang hebben.Dit wordt gebruikt bij overerving (inheritance) en gaan we pas zien in hoofdstuk 7.class Voertuig { protected int Snelheid; // Alleen toegankelijk voor Voertuig en subklassen public void Versnel(int waarde) { Snelheid += waarde; } } class Auto : Voertuig // Auto erft van Voertuig { public void ToonSnelheid() { Console.WriteLine($"Snelheid: {Snelheid} km/u"); // Toegankelijk omdat het protected is } } Auto mijnAuto = new Auto(); mijnAuto.Versnel(20); mijnAuto.ToonSnelheid(); // Werkt, want Auto erft van Voertuig! internal betekent dat de klasse of methode alleen toegankelijk is binnen hetzelfde project.Dit is handig wanneer je code wilt afschermen voor externe projecten.internal class DatabaseConnector { public void Verbinden() { Console.WriteLine("Verbonden met database!"); } } DatabaseConnector db = new DatabaseConnector(); db.Verbinden(); // Werkt alleen binnen dit project Je kunt access modifiers combineren met properties en methoden.public class Auto { private string Merk; public string MerkProperty { get { return Merk; } private set { Merk = value; } // Alleen binnen de klasse kan Merk gewijzigd worden! } } ✅ Voorkomt directe wijzigingen van buitenaf. ✅ Laat alleen wijzigingen toe via methoden binnen de klasse.✅ Public → Iedereen heeft toegang. Gebruik voor methoden, maar niet voor variabelen. ✅ Private → Alleen toegankelijk binnen dezelfde klasse. Gebruik voor veiligheid en inkapseling. ✅ Protected → Alleen toegankelijk voor de klasse en subklassen. Gebruik bij overerving. ✅ Internal → Alleen toegankelijk binnen hetzelfde project. Gebruik bij afgeschermde code. ✅ Gebruik properties en methoden in plaats van public variabelen.

3.7 - Naming conventions

Fri, 20 Jun 2025 08:52:06 GMT

In C# is duidelijke en consequente naamgeving superbelangrijk. Het maakt je code leesbaar, onderhoudbaar én professioneel. Microsoft heeft officiële richtlijnen opgesteld, en in deze paragraaf leer je de belangrijkste conventies die je hoort te volgen. ❌ Geen afkortingen of cryptische namen (x1, aa, vGslp) ✅ Gebruik duidelijke, beschrijvende namen (aantalStudenten, berekenFactuur()). Beter een wat langere naam die wel duidelijk is, dan krampachtig een korte naam kiezen die onduidelijk is! ❌ Geen underscores in methodenamen: gebruik hoofdletters (ToonResultaat, niet toon_resultaat) ✅ Begin niet met cijfers of speciale tekens Klassen worden opgeslagen in bestanden met dezelfde naam: BankRekening.cs bevat de klasse BankRekening Eén klasse per bestand is aangeraden Geen spaties of accenten in bestandsnamen ✅ Gebruik PascalCase voor klassen, methodes en properties ✅ Gebruik camelCase voor variabelen, parameters en objecten ✅ Constantes schrijf je in HOOFDLETTERS_MET_UNDERSCORES ✅ Kies duidelijke, betekenisvolle namen!

4.2 - Variabelen, constanten en datatypes

Fri, 20 Jun 2025 08:44:05 GMT

Alles wat je momenteel op je pc uitvoert, bestaat uit een reeks berekeningen. Zelfs het verplaatsen van je muis op het scherm is een berekening: de computer berekent hoe jouw invoer het muisicoon moet verplaatsen.In een programmeertaal werken we altijd met gegevens. Deze gegevens worden tijdelijk in het geheugen van de computer opgeslagen, zodat er bewerkingen mee kunnen worden uitgevoerd. De manier waarop deze gegevens worden opgeslagen en verwerkt, hangt af van het datatype.Een variabele is een geheugenplaats waarin een waarde kan worden opgeslagen. De naam variabele komt voort uit het feit dat de waarde kan veranderen tijdens de uitvoering van het programma. We schrijven de naam van een variabele met een kleine letter.Elke variabele heeft: ✅ Een datatype (bijv. int, double, bool) ✅ Een unieke naam (bijv. a, b, som) ✅ Een waarde (die kan veranderen)int a; // Declaratie van een variabele van type int int b; int c; a = 1; // Initialisatie: waarde toekennen b = 2; c = a + b; // Berekening met variabelen Console.WriteLine("1 + 2 = " + c); Hier maken we drie variabelen (a, b, c) aan van het type int (geheel getal). Declareren: Een variabele aanmaken zonder direct een waarde toe te kennen. int leeftijd; Initialiseren: Een variabele direct een waarde geven. int leeftijd = 25; Je kunt meerdere variabelen tegelijk declareren:int a, b, c; Hoewel dit compacter is, wordt het vaak afgeraden omdat het minder overzichtelijk is.Een datatype bepaalt welk soort gegevens een variabele kan opslaan. C# heeft verschillende primitieve datatypes die standaard beschikbaar zijn: Efficiënt geheugenbeheer: Een int gebruikt minder geheugen dan een long. Correcte berekeningen: Een double is nauwkeuriger dan een float. Typeveiligheid: Een bool kan alleen true of false zijn, wat fouten voorkomt. Tijdens deze cursus werken we vooral met int, double, bool en char. Hoewel string geen primitief datatype is, gebruiken we het vaak en behandelen we het als een basisdatatype.Naast variabelen bestaan er ook constanten. Een constante is een variabele waarvan de waarde niet kan veranderen na initialisatie. Voorkomt onbedoelde wijzigingen Maakt code leesbaarder Verbetert prestaties (de compiler optimaliseert constanten) const double PI = 3.14159; const int MAXIMUM_LEEFTIJD = 120; Merk op dat constanten in hoofdletters worden geschreven. Dit is een programmeerconventie om ze te onderscheiden van gewone variabelen.✅ Variabelen slaan gegevens op die kunnen veranderen. ✅ Datatypes bepalen welk soort gegevens een variabele kan bevatten. ✅ Constanten zijn variabelen waarvan de waarde niet kan veranderen.Door deze concepten goed te begrijpen, kun je efficiënte en foutloze programma’s schrijven. In de volgende paragraaf behandelen we operatoren en hoe je berekeningen uitvoert in C#

5.3 - Constructors

Fri, 20 Jun 2025 08:43:04 GMT

Een constructor is een speciale methode van een klasse die alleen wordt uitgevoerd wanneer er een object van die klasse wordt aangemaakt.Je herkent een constructor aan het gebruik van new.Random rand = new Random(); Hier wordt een nieuw Random-object aangemaakt. Achter de schermen roept de klasse Random een constructor aan. Belangrijk: Elke klasse heeft altijd een constructor, zelfs als je er zelf geen definieert! Een default constructor is een constructor zonder parameters.Als je geen constructor schrijft, zal C# automatisch een default constructor genereren.public class Auto { public Auto() // Default constructor { Console.WriteLine("Een Auto-object is aangemaakt!"); } } Auto mijnAuto = new Auto(); Hier wordt een nieuw Auto-object aangemaakt, en de default constructor wordt automatisch aangeroepen. Merk op dat er een WriteLine wordt uitgevoerd als je deze constructor oproept! Een default constructor heeft dus geen parameters (oftewel: er staat niks tussen de ronde haakjes), maar kan wel code uitvoeren!Een parameter constructor accepteert argumenten bij het maken van een object.Hiermee kun je een object direct een waarde geven bij creatie.public class Auto { public string Merk; public string Kleur; public int AantalDeuren; public Auto(string merk, string kleur, int aantalDeuren) // Parameter constructor { Merk = merk; Kleur = kleur; AantalDeuren = aantalDeuren; } } Auto mijnAuto = new Auto("Tesla", "Rood", 4); Console.WriteLine($"Merk: {mijnAuto.Merk}, Kleur: {mijnAuto.Kleur}, Aantal deuren: {mijnAuto.AantalDeuren}"); Hier wordt een Auto-object aangemaakt met direct een merk, kleur en aantal deuren.Een copy constructor maakt een nieuw object door de waarden van een bestaand object te kopiëren.Dit is handig wanneer je een exacte kopie wilt maken zonder handmatig alle eigenschappen over te zetten.public class Auto { public string Merk; public string Kleur; public int AantalDeuren; // Default constructor public Auto() { } // Parameter constructor public Auto(string merk, string kleur, int aantalDeuren) { Merk = merk; Kleur = kleur; AantalDeuren = aantalDeuren; } // Copy constructor public Auto(Auto bestaandAuto) { Merk = bestaandAuto.Merk; Kleur = bestaandAuto.Kleur; AantalDeuren = bestaandAuto.AantalDeuren; } } Auto auto1 = new Auto("Tesla", "Rood", 4); Auto auto2 = new Auto(auto1); // Kopie van auto1 Console.WriteLine($"Auto1 - Merk: {auto1.Merk}, Kleur: {auto1.Kleur}, Deuren: {auto1.AantalDeuren}"); Console.WriteLine($"Auto2 - Merk: {auto2.Merk}, Kleur: {auto2.Kleur}, Deuren: {auto2.AantalDeuren}"); auto2.Kleur = "Blauw"; // Wijziging in auto2 Console.WriteLine("Na wijziging van auto2:"); Console.WriteLine($"Auto1 - Merk: {auto1.Merk}, Kleur: {auto1.Kleur}, Deuren: {auto1.AantalDeuren}"); Console.WriteLine($"Auto2 - Merk: {auto2.Merk}, Kleur: {auto2.Kleur}, Deuren: {auto2.AantalDeuren}"); Hier wordt auto2 een aparte kopie van auto1. Je kunt auto2 wijzigen zonder dat auto1 verandert.Je kunt een alternatieve copy constructor maken die direct de instance constructor aanroept.public Auto(Auto bestaandAuto) : this(bestaandAuto.Merk, bestaandAuto.Kleur, bestaandAuto.AantalDeuren) { } Hier roept de copy constructor automatisch de parameter constructor aan.Meer uitleg over copy constructors en alternatieven vind je op Microsoft Learn.✅ Default constructor → Geen parameters, wordt automatisch aangemaakt als je er geen schrijft. ✅ Parameter constructor → Objecten initialiseren met argumenten. ✅ Copy constructor → Kopieert een bestaand object zonder referentie te delen. ✅ Alternatieve copy constructor → Roept de instance constructor aan om duplicatie te voorkomen.

5.2 - Objecten

Fri, 20 Jun 2025 08:39:15 GMT

Een object is een instantie van een klasse. Wanneer je een klasse hebt gedefinieerd, kun je objecten maken die de eigenschappen en methoden van die klasse gebruiken. Bijvoorbeeld: als je een klasse "Auto" hebt, kun je een object "MijnAuto" maken dat een specifieke kleur, merk en snelheid heeft.Objecten bestaan overal om ons heen. Denk aan een fiets, hond, telefoon, boek—ze hebben allemaal eigenschappen en gedrag. Je maakt een object door het sleutelwoord new te gebruiken. class Auto { public string Kleur; public string Merk; public int Snelheid; } Auto mijnAuto = new Auto(); // Object maken mijnAuto.Kleur = "Rood"; mijnAuto.Merk = "Tesla"; mijnAuto.Snelheid = 0; Console.WriteLine($"Mijn auto is een {mijnAuto.Merk} en heeft de kleur {mijnAuto.Kleur}."); Hier maken we een Auto-object met de eigenschappen kleur, merk en snelheid.Je kunt objecten aanpassen door hun eigenschappen te wijzigen.mijnAuto.Snelheid += 20; // Auto versnellen Console.WriteLine($"De auto rijdt nu {mijnAuto.Snelheid} km/u."); Hier verhogen we de snelheid van het object mijnAuto.Een klasse is een blauwdruk, een object is een echte instantie van die klasse.Meer uitleg over objecten vind je op Microsoft Learn.✅ Een object is een instantie van een klasse. ✅ Objecten hebben eigenschappen (variabelen) en gedrag (methoden). ✅ Gebruik new om een object aan te maken. ✅ Objecten kunnen worden aangepast na creatie. ✅ Een klasse is een blauwdruk, een object is een werkende instantie.In de volgende paragraaf behandelen we constructors, waarmee je objecten efficiënt kunt initialiseren!

5.0 - Inleiding

Fri, 20 Jun 2025 08:34:57 GMT

In dit hoofdstuk duiken we dieper in Object-Oriented Programming (OOP), een fundamenteel concept in C#. OOP is een programmeerparadigma dat software structureert rond objecten en klassen. Dit maakt code herbruikbaar, modulair en makkelijk te onderhouden.Objectgeoriënteerd programmeren (OOP) is een manier van programmeren waarbij je software opbouwt uit objecten die samenwerken. Een object is een virtuele representatie van iets uit de echte wereld. Denk aan een auto, gebruiker, bankrekening of spelkarakter. Elk object heeft: ✅ Eigenschappen (zoals kleur, snelheid, saldo) ✅ Gedrag (zoals rijden, betalen, springen) Deze objecten worden gemaakt op basis van klassen. Een klasse is een blauwdruk voor een object. OOP biedt veel voordelen: ✅ Modulariteit → Code wordt opgesplitst in kleine, herbruikbare stukken. ✅ Herbruikbaarheid → Klassen kunnen opnieuw gebruikt worden in andere projecten. ✅ Onderhoudbaarheid → Code is makkelijker te begrijpen en aan te passen. ✅ Flexibiliteit → Objecten kunnen eenvoudig worden uitgebreid en aangepast. OOP is gebaseerd op vier fundamentele principes: Verbergt interne details van een object en biedt alleen toegang via methoden. Voorkomt dat andere delen van de code direct interne variabelen wijzigen. Voorbeeld: class Auto { private int snelheid; // Verborgen variabele public void Versnel(int waarde) { snelheid += waarde; // Alleen via deze methode kan snelheid worden aangepast } } Verbergt complexe implementatie en toont alleen wat nodig is. Voorbeeld: abstract class Dier { public abstract void MaakGeluid(); // Abstracte methode } class Hond : Dier { public override void MaakGeluid() { Console.WriteLine("Woef!"); } } Laat een klasse eigenschappen en gedrag overnemen van een andere klasse. Voorbeeld: class Voertuig { public int Snelheid { get; set; } } class Auto : Voertuig // Auto erft van Voertuig { public string Merk { get; set; } } Laat objecten van verschillende klassen op dezelfde manier worden behandeld. Voorbeeld: class Dier { public virtual void MaakGeluid() { Console.WriteLine("Dier maakt geluid"); } } class Kat : Dier { public override void MaakGeluid() { Console.WriteLine("Miauw!"); } }

5.1 - Klassen

Fri, 20 Jun 2025 08:33:44 GMT

Een klasse is een fundamenteel onderdeel van objectgeoriënteerd programmeren (OOP). In C# vormen klassen de blauwdruk voor objecten. Wanneer je een solution aanmaakt in Rider, wordt automatisch de klasse Program.cs gegenereerd. Dit is de standaardklasse die altijd aanwezig moet zijn in elk project. Vanaf .NET 6 is deze klasse versimpeld, waardoor je direct code kunt schrijven zonder expliciete Main()-methode. Maar ins ons geval willen we juist wel deze Main-methode gebruiken, omdat dit ons beter leert wat er precies gebeurt binnen de Program-klasse.Een klasse is een samenhangend geheel van: ✅ Variabelen (eigenschappen van een object) ✅ Methoden (gedrag van een object) ✅ Constructors (hoe een object wordt aangemaakt) Een klasse definieert wat een object is en hoe het zich gedraagt.Veel dingen in het echte leven kunnen als klasse worden gezien. Bijvoorbeeld: Auto → Een klasse die eigenschappen heeft zoals kleur, merk, snelheid. Gebruiker → Een klasse met naam, leeftijd, emailadres. Bankrekening → Een klasse met saldo, rekeningnummer, transacties. Een klasse is dus een blauwdruk voor objecten. Elk object dat je maakt vanuit een klasse is een instantie van die klasse. class Auto { public string Kleur; public string Merk; public int Snelheid; public void Versnel(int waarde) { Snelheid += waarde; } } Hier definieert de klasse Auto eigenschappen zoals kleur, merk en snelheid.Het aanmaken van een nieuwe klasse in Rider is eenvoudig:1️⃣ Klik met de rechtermuisknop op je project of map. 2️⃣ Ga naar Add → Class/Interface. 3️⃣ Geef een naam aan je klasse (bijv. Auto). 4️⃣ Druk op Enter.Je nieuwe klasse verschijnt nu in de Solution Explorer.Heb je een verkeerde naam gegeven? Gebruik Refactor → Rename in Rider om de naam correct te wijzigen.Elke klasse in C# hoort bij een namespace.namespace MijnProject { public class Auto { public string Kleur; public string Merk; public int Snelheid; } } Hier zeggen we dat de klasse Auto onderdeel is van de namespace MijnProject.Namespaces helpen om code te organiseren en conflicten te voorkomen.✅ Klassen zijn blauwdrukken voor objecten. ✅ Objecten zijn instanties van een klasse. ✅ Klassen bevatten variabelen en methoden. ✅ Gebruik namespaces om code te organiseren. ✅ Maak klassen aan in Rider via Add → Class.

4.10 - Datum en tijd

Thu, 19 Jun 2025 10:02:12 GMT

Wanneer je applicaties schrijft, zul je vaak moeten werken met datum- en tijdgegevens.C# heeft hiervoor een ingebouwde DateTime-klasse, waarmee je eenvoudig datums en tijden kunt beheren.Net zoals bij Random, moeten we een DateTime-object aanmaken om met datum en tijd te werken.DateTime dt = new DateTime(); Console.WriteLine(dt.ToString()); Output:01-01-0001 00:00:00 Dit is de standaard datum en tijd (1 januari 0001, 00:00:00).Wil je de huidige datum en tijd? Gebruik DateTime.Now.DateTime vandaag = DateTime.Now; Console.WriteLine(vandaag); Output (voorbeeld):17-05-2025 09:58:44 Hier worden dag, maand, jaar, uur, minuten en seconden weergegeven.Wil je een specifieke datum instellen? Geef de jaar, maand en dag als argumenten mee.DateTime dt = new DateTime(2025, 05, 10); Console.WriteLine(dt.ToString()); Output:10-05-2025 00:00:00 Let op: De tijd wordt standaard ingesteld op 00:00:00. Wil je ook een specifieke tijd instellen? Voeg uur, minuten en seconden toe.DateTime dt = new DateTime(2025, 05, 10, 18, 42, 05); Console.WriteLine(dt.ToString()); Output:10-05-2025 18:42:05 Let op: Dit gebruikt de 24-uurs notatie. Wil je AM/PM, dan moet je de ToString()-format aanpassen. Je kunt dagen, uren, minuten toevoegen of aftrekken met Add() en Subtract().DateTime nu = DateTime.Now; DateTime volgendeWeek = nu.AddDays(7); DateTime vorigeMaand = nu.AddMonths(-1); Console.WriteLine($"Nu: {nu}"); Console.WriteLine($"Volgende week: {volgendeWeek}"); Console.WriteLine($"Vorige maand: {vorigeMaand}"); Hier wordt 7 dagen toegevoegd en 1 maand afgetrokken.Wil je weten hoeveel dagen, uren of minuten er tussen twee datums zitten? Gebruik TimeSpan.DateTime start = new DateTime(2025, 05, 01); DateTime einde = new DateTime(2025, 05, 10); TimeSpan verschil = einde - start; Console.WriteLine($"Dagen verschil: {verschil.Days}"); Console.WriteLine($"Uren verschil: {verschil.TotalHours}"); Output:Dagen verschil: 9 Uren verschil: 216 Hier berekenen we het verschil in dagen en uren tussen 1 mei en 10 mei.Wil je een mooie weergave van datum en tijd? Gebruik ToString() met een format.DateTime nu = DateTime.Now; Console.WriteLine(nu.ToString("dd-MM-yyyy")); // Output: 17-05-2025 Console.WriteLine(nu.ToString("yyyy/MM/dd HH:mm:ss")); // Output: 2025/05/17 09:58:44 Console.WriteLine(nu.ToString("dddd, MMMM dd yyyy")); // Output: Zaterdag, Mei 17 2025 Hier gebruiken we verschillende formatten om de datum en tijd anders weer te geven.✅ DateTime.Now → Huidige datum en tijd. ✅ DateTime(jaar, maand, dag) → Specifieke datum instellen. ✅ DateTime(jaar, maand, dag, uur, minuut, seconde) → Specifieke datum en tijd instellen. ✅ AddDays(), AddMonths() → Datum manipuleren. ✅ TimeSpan → Verschil tussen twee datums berekenen. ✅ ToString("format") → Datum en tijd formatteren.

4.9 - Math

Thu, 19 Jun 2025 09:59:18 GMT

C# bevat veel ingebouwde klassenbibliotheken die ons helpen bij het programmeren.Deze bibliotheken bevatten kant-en-klare methoden die we kunnen gebruiken zonder ze zelf te hoeven schrijven.In de vorige paragraaf hebben we gekeken naar de Random-klasse, die willekeurige getallen genereert.Nu bekijken we de Math-klasse, die ons helpt bij wiskundige berekeningen zoals: ✅ Afronden (Round, Floor, Ceiling) ✅ Machtsverheffen (Pow) ✅ Min & Max (Min, Max) ✅ Worteltrekken (Sqrt) ✅ Trigonometrie (Sin, Cos, Tan)Met Math.Round() kun je een getal afronden.double getal = 12.434565; Console.WriteLine(Math.Round(getal)); // Output: 12 Hier wordt 12.434565 afgerond naar 12.Wil je afronden op een specifiek aantal decimalen?Console.WriteLine(Math.Round(getal, 4)); // Output: 12.4346 Hier wordt getal afgerond op 4 decimalen.Wil je altijd naar beneden afronden? Gebruik Math.Floor():Console.WriteLine(Math.Floor(getal)); // Output: 12 Wil je altijd naar boven afronden? Gebruik Math.Ceiling():Console.WriteLine(Math.Ceiling(getal)); // Output: 13 Met Math.Pow() kun je een getal tot een bepaalde macht verheffen.double getal = 6; double resultaat = Math.Pow(getal, 3); // 6³ = 216 Console.WriteLine(resultaat); Hier wordt 6 tot de derde macht verheven (6 * 6 * 6 = 216).Met Math.Min() en Math.Max() kun je de laagste of hoogste waarde van twee getallen vinden.int getal1 = 503; int getal2 = 767; Console.WriteLine(Math.Min(getal1, getal2)); // Output: 503 Console.WriteLine(Math.Max(getal1, getal2)); // Output: 767 Hier wordt de laagste waarde (503) en de hoogste waarde (767) weergegeven.Met Math.Sqrt() kun je de vierkantswortel van een getal berekenen.double getal = 64; Console.WriteLine(Math.Sqrt(getal)); // Output: 8 Hier wordt de wortel van 64 berekend (√64 = 8).Met Math.Sin(), Math.Cos() en Math.Tan() kun je sinus, cosinus en tangens berekenen.double hoek = Math.PI / 4; // 45 graden in radialen Console.WriteLine(Math.Sin(hoek)); // Sinus van 45° Console.WriteLine(Math.Cos(hoek)); // Cosinus van 45° Console.WriteLine(Math.Tan(hoek)); // Tangens van 45° Hier worden de sinus, cosinus en tangens van 45 graden berekend.✅ Math.Round() → Afronden op een geheel getal of aantal decimalen. ✅ Math.Floor() → Altijd naar beneden afronden. ✅ Math.Ceiling() → Altijd naar boven afronden. ✅ Math.Pow() → Machtsverheffen (x^y). ✅ Math.Min() / Math.Max() → Kleinste/grootste waarde vinden. ✅ Math.Sqrt() → Vierkantswortel berekenen. ✅ Math.Sin(), Math.Cos(), Math.Tan() → Trigonometrische functies.

4.1 - Algoritmes

Thu, 19 Jun 2025 09:43:59 GMT

Een algoritme is een reeks instructies die in een specifieke volgorde worden uitgevoerd om een bepaald doel te bereiken. Wanneer je programmeert, bedenk je in feite algoritmes om problemen op te lossen en vertaal je deze naar een programmeertaal zodat de computer ze kan uitvoeren. #### Algoritmes in het dagelijks leven Je kent algoritmes misschien al uit de wiskundelessen: een algoritme is niets meer dan een **stappenplan** om een probleem op te lossen. Neem het menu Lees het menu Bel Pizzaphone Geef je keuze door Geef je adres door Wacht tot de bel gaat Open de deur Betaal Neem de pizza aan Op het eerste gezicht lijkt deze volgorde prima, maar een computer heeft gedetailleerde en ondubbelzinnige instructies nodig. Loop naar het telefoonkastje Open de lade Haal de stapel foldertjes eruit Neem het bovenste foldertje Controleer: is dit de folder van Pizzaphone? Ja: Ga verder naar de volgende stap Nee: Is dit de laatste folder in de lade? Ja: Honger lijden… Nee: Leg het foldertje terug en ga terug naar stap 4 Hier zie je dat een algoritme beslissingen en herhalingen kan bevatten. Een algoritme moet: ✅ Eindig zijn – het moet na een bepaald aantal stappen stoppen. ✅ Helder zijn – elke stap moet duidelijk en ondubbelzinnig zijn. ✅ Uitvoerbaar zijn – elke stap moet praktisch uitvoerbaar zijn. ✅ Invoer en uitvoer hebben – het algoritme gebruikt data en levert een resultaat op. Input vragen (bijv. invoer van de gebruiker) Output geven (bijv. een berekend resultaat tonen) Iets testen (bijv. controleren of een waarde voldoet aan een bepaalde voorwaarde) Een aantal stappen herhalen (bijv. een loop die meerdere keren wordt uitgevoerd) Iets berekenen (bijv. optellen, aftrekken, sorteren) Conclusie: Een algoritme is een gestructureerde reeks stappen waarbij de volgorde cruciaal is. Verwacht niet dat een computer begrijpt wat je bedoelt—je moet elke stap expliciet definiëren!

1.3 - Geschiedenis van programmeertalen

Thu, 19 Jun 2025 09:35:19 GMT

### 1.3.0 - MachinetaalMachinetaal is een taal waarbij er rechtstreeks instructies aan de processor van de computer gegeven kunnen worden. Een processor kan namelijk alleen maar instructies uitvoeren die in machinetaal geschreven zijn. Elke regel code is hierbij gelijk aan één instructie die de processor moet uitvoeren. Dat kan zijn het inladen of het opvragen van bepaalde waarden, een berekening doen, etc. Dit is de oertaal binnen elke applicatie! Zelfs alle hedendaagse applicaties worden namelijk nog altijd omgezet in machinetaal. Ook door nog maar naar deze cursus te kijken is je processor enorme hoeveelheden instructies achter elkaar aan het uitvoeren. Je kunt je dus wel voorstellen dat een applicatie schrijven in machinetaal vandaag de dag onbegonnen werk is. Zeker als je bedenkt dat elke instructie geschreven moet worden in 8 bits (in een combinatie van 1 en 0), zoals op onderstaand voorbeeld te zien is:Omdat programmeren in pure machinetaal veel te omslachtig en tijdrovend is, bedacht men in de jaren ’50 een assembleertaal (of Assembly). Dit is een low-level taal die eigenlijk niks meer is dan een symbolische weergave van machinetaal. Elke regel in Assembly komt overeen met één enkele instructie in machinetaal, maar dan nét iets leesbaarder weergegeven. Elke processor heeft een eigen set aan instructies, waardoor het probleem bleef bestaan dat software ontwikkeld in Assembly niet op iedere computer gebruikt kon worden.
Fortran (FORmula TRANslation) was de allereerste “echte” high-level taal, ontwikkeld door IBM voor wetenschappelijke en technische berekeningen. Programmeurs konden wiskundige formules in leesbare notatie schrijven, waarna een compiler die omzet in machinecode. Fortran legde de basis voor latere optimalisatietechnieken in compilers en wordt nog altijd gebruikt in HPC (high-performance computing).
Lisp (LISt Processing) is de oudste functionele programmeertaal, ontworpen voor onderzoek in kunstmatige intelligentie. Ze introduceerde concepten als recursie, garbage collection en dynamische datatypes. De kenmerkende notatie met veel haakjes was destijds revolutionair en vormt de inspiratie voor latere functionele talen.
Algol (ALGOrithmic Language) bood voor het eerst een gestandaardiseerde blokstructuur (begin…end) en had een grote invloed op bijna alle talen die daarna kwamen, waaronder Pascal, C en Java. Algol introduceerde ook de BNF-notatie die we nu nog gebruiken om grammatica’s te beschrijven
In 1959 werd de taal COBOL ontwikkeld voor de zakelijke markt. COBOL staat voor Common Business Oriented Language (=algemeen zakelijk georiënteerde taal). COBOL was één van de eerste talen die probeerde de Engelse taal na te bootsen. Dit maakte het veel gemakkelijker voor de programmeurs om mee te werken. Ook was één van de eisen die men aan de taal stelde dat men software kon schrijven die gebruikt kon worden op computers met verschillende typen processors.
BASIC is ontwikkeld in 1964 om mensen snel te leren programmeren. BASIC staat voor Beginners All-purpose Symbolic Instruction Code. Deze taal werd speciaal ontwikkeld voor universiteitsstudenten die een niet-technische of abstracte richting studeerden.
Vanaf de jaren ’70 werden er steeds meer programmeertalen ontwikkeld. In 1973 werd de taal C ontwikkeld. C wordt gezien als één van de belangrijkste talen -zo niet dé belangrijkste- die ontwikkeld zijn. Zelfs relatief nieuwe talen als C#, Java, Javascript, PHP, etc. zijn gebaseerd op C.
SQL staat voor Structured Query Language en is een beetje een vreemde taal in dit rijtje. SQL is namelijk geen pure programmeertaal, maar een scripttaal ontwikkeld voor creatie en beheer van relationele databanken en is sinds de jaren ’80 de standaardtaal hiervoor geworden.
C++ is één van de belangrijkste talen die nog altijd gebruikt wordt. In 1983 ontwikkeld door Bjarne Stroustrup en gebaseerd op de taal C, maar dan veel uitgebreider.
Python werd in 1991 ontworpen door de Nederlander Guido van Rossum voor het Centrum voor Wiskunde en Informatica in Amsterdam. Python is een taal gebaseerd op BASIC, maar dan veel uitgebreider. Er wordt nog altijd veel gesleuteld aan de taal en het is open-source. De belangrijkste eis bij het ontwikkelen van de taal was leesbaarheid van de code: met weinig code kan een programmeur veel instructies geven. Python wordt geleverd met een grote bibliotheek aan standaardcodes. Hierdoor is het erg eenvoudig om herbruikbare code te schrijven. Deze bibliotheken kunnen door programmeurs ook zelf worden gemaakt en gratis worden verspreid. Hierdoor ontwikkelt de taal zich snel binnen korte tijd en kunnen relatief snel nieuwe applicaties worden geschreven, zonder dat de code onleesbaar wordt. Python is volgens velen een goede keuze om als eerste taal te leren, omdat er minder geschreven moet worden dan in andere talen. Dat kan echter ook een nadeel zijn, indien je dan later in andere talen juist extra zaken moet bijleren.
Java is ontwikkeld in 1995 als OOPL dat platformonafhankelijk moest zijn. Het is grotendeels gebaseerd op C++, maar dan met een veel uitgebreidere klassenbibliotheek. Platformonafhankelijk wil zeggen dat applicaties die op een computer met Windows zijn geschreven, ook kunnen werken op MacOS of Linux (mits op deze computers de Java Virtual Machine is geïnstalleerd). Dit is pas veel later voor talen als C++ of Python ingebouwd. Vanaf het begin af aan is Java erg populair geworden om applicaties voor grote bedrijven te ontwikkelen, om in het onderwijs te gebruiken om OOP aan te leren, om apps voor mobiele telefoons en later ook om grotere games mee te ontwikkelen. Als OOPL is Java relatief eenvoudig te leren, zeker wanneer je kijkt naar hoe veelzijdig de taal is. Veel programmeurs vinden Java overzichtelijker dan C++, maar Java mist enkele functies die C++ wel heeft. In vergelijking met Python moet er meer geschreven worden om hetzelfde te bereiken, maar dat kan weldegelijk een voordeel zijn, aangezien het gemakkelijker is om zaken weg te laten dan erbij te moeten leren.
Ontwikkeld door Brendan Eich bij Netscape om interactieve elementen in webbrowsers mogelijk te maken. JavaScript draait in vrijwel alle browsers, is event-gedreven en – dankzij Node.js – inmiddels ook server-side populair.
Oorspronkelijk “Personal Home Page Tools”, later “PHP: Hypertext Preprocessor”. Deze scripttaal is ontworpen voor server-side webdevelopment en is eenvoudig in HTML te embedden.
Geschapen door Yukihiro “Matz” Matsumoto als een taal met de nadruk op programmeursgeluk. Ruby is puur objectgeoriënteerd en elegant van opzet.
In 2001 heeft Microsoft C# (spreek uit als 'C sharp') ontwikkeld. C# is ook een OOPL en lijkt zeer sterk op Java. Microsoft zag het succes van Java en wilde hier een eigen tegenhanger voor ontwikkelen. Naast desktop- en serverapplicaties, wordt C# ook veel gebruikt om software te ontwikkelen voor smartphones en games. Een bekende (gratis) engine die gebruikt wordt om games mee te ontwikkelen is Unity. Unity gebruikt C# om in te programmeren. De overstap van C# naar Java en omgekeerd is voor veel programmeurs eenvoudig, aangezien de syntaxis erg op elkaar lijkt en beide talen ongeveer dezelfde instructies kennen.
Scratch is een programmeertaal ontwikkeld in 2006 door MIT en richt zich op kinderen vanaf 8 jaar die graag willen leren programmeren. Het bijzondere aan deze taal is dat het werkt met visuele blokjes in plaats van enkel tekstcode. Codefouten blijven altijd mogelijk, maar de blokjes maken het levendiger en daardoor gemakkelijker voor kinderen om te leren. Scratch is tegenwoordig online te gebruiken in je browser en is zelfs in het Nederlands vertaald!
Ook bekend als Golang, ontwikkeld door Google om systeemtalen (‘C-achtige performance’) te combineren met een moderne, garbage-collected runtime en ingebouwde ondersteuning voor concurrency (goroutines).
Apple’s opvolger van Objective-C, met een sterk getypeerd, expressief en veilig ontwerp. Swift integreert moderne taalfeatures zoals optionele types (nil-veiligheid), closures en protocol-georiënteerd programmeren.
Rust van Mozilla legt de lat hoog op geheugen- en threadveiligheid zonder garbage collector. Via ownership en borrow checker voorkom je data races en geheugenlekken al tijdens het compileren.

4.7 - Loops

Thu, 19 Jun 2025 09:25:35 GMT

In C#, net als in vrijwel elke andere programmeertaal, kun je een statement of bewerking herhalen.Dit is handig als je wilt dat een computer een bepaalde berekening meerdere keren uitvoert, bijvoorbeeld totdat een specifiek getal is bereikt.Dit proces heet iteratie, en elke keer dat de loop wordt uitgevoerd, noemen we een iteratie.C# ondersteunt verschillende soorten loops: ✅ While-loop → Herhaalt zolang een voorwaarde true is. ✅ For-loop → Herhaalt een vast aantal keer. ✅ Foreach-loop → Itereert door een collectie (zoals een array of lijst). ✅ Do-while-loop → Herhaalt minstens één keer, daarna zolang een voorwaarde true is.Meer uitleg over loops vind je op Microsoft Learn.Een while-loop herhaalt een stuk code zolang een bepaalde voorwaarde true is.while (voorwaarde) { // Code die wordt herhaald zolang de voorwaarde true is } Voorbeeld:int getal = 1; while (getal < 10) { Console.WriteLine(getal); getal += 1; // Verhoog getal met 1 } Hier blijft de loop doorlopen totdat getal 10 of groter is. Belangrijk: Zorg ervoor dat de voorwaarde ooit false wordt, anders krijg je een endless loop! Een for-loop verschilt van een while-loop omdat je meer controle hebt over het aantal herhalingen.for (startwaarde; voorwaarde; increment) { // Code die wordt herhaald } Voorbeeld:for (int i = 0; i < 5; i++) { Console.WriteLine($"Getal: {i}"); } Hier gebeurt het volgende: Startwaarde → int i = 0 (de loop begint bij 0). Voorwaarde → i < 5 (de loop stopt als i 5 of groter is). Increment → i++ (bij elke iteratie wordt i met 1 verhoogd).
Een foreach-loop is speciaal ontworpen om door een collectie (zoals een array of lijst) te itereren.foreach (datatype item in collectie) { // Code die wordt uitgevoerd voor elk item in de collectie } Voorbeeld:string[] namen = { "Alice", "Bob", "Charlie" }; foreach (string naam in namen) { Console.WriteLine($"Hallo, {naam}!"); } Hier wordt elke naam in de array namen één voor één verwerkt.
Meer uitleg over de for-each loop komt aan bod in hoofdstuk 6.Een do-while-loop lijkt op een while-loop, maar wordt altijd minstens één keer uitgevoerd.do { // Code die minstens één keer wordt uitgevoerd } while (voorwaarde); Voorbeeld:int getal = 1; do { Console.WriteLine(getal); getal++; } while (getal < 5); Hier wordt Console.WriteLine(getal); altijd minstens één keer uitgevoerd, zelfs als getal niet kleiner dan 5 is.
Een endless loop is een loop die nooit stopt, waardoor je programma vastloopt.Voorbeeld van een endless loop:int teller = 10; int product = 1; while (teller < 100) { product = product * teller; // FOUT: teller wordt nooit aangepast! } Hier blijft de while-loop oneindig doorlopen, omdat teller nooit verandert.
Oplossing: Zorg ervoor dat de voorwaarde ooit false wordt, bijvoorbeeld door teller++ toe te voegen. ✅ While-loop → Herhaalt zolang een voorwaarde true is. ✅ For-loop → Herhaalt een vast aantal keer. ✅ Foreach-loop → Itereert door een collectie (zoals een array). ✅ Do-while-loop → Wordt altijd minstens één keer uitgevoerd. ✅ Endless loop → Zorg ervoor dat de voorwaarde ooit false wordt!

4.6 - Conditionals

Thu, 19 Jun 2025 08:56:47 GMT

Computerprogramma's zijn weinig zinvol als ze altijd hetzelfde doen. Vaak wil je dat een programma beslissingen neemt op basis van een bepaalde voorwaarde. Dit gebeurt met conditionele statements.In C# kun je gebruik maken van: ✅ if → Voert code uit als een bepaalde voorwaarde true is. ✅ else → Voert code uit als de if-voorwaarde false is. ✅ else if → Voegt extra voorwaarden toe. ✅ switch → Handig als je meerdere vaste waarden wilt controleren.Een if-statement controleert of een voorwaarde waar (true) is.if (voorwaarde) { // Code die wordt uitgevoerd als de voorwaarde true is } Voorbeeld:int leeftijd = 20; if (leeftijd >= 18) { Console.WriteLine("Je mag stemmen!"); } Hier controleert het programma of leeftijd groter dan of gelijk aan 18 is. Als dat zo is, wordt "Je mag stemmen!" weergegeven.
Soms wil je dat er iets anders gebeurt als de if-voorwaarde false is. Dit doe je met else.
if (voorwaarde) { // Code als de voorwaarde true is } else { // Code als de voorwaarde false is } Voorbeeld:int leeftijd = 15; if (leeftijd >= 18) { Console.WriteLine("Je mag stemmen!"); } else { Console.WriteLine("Je bent te jong!"); } Hier wordt "Je bent te jong!" weergegeven omdat leeftijd kleiner dan 18 is.
Soms wil je meerdere voorwaarden controleren. Dit doe je met else if.if (voorwaarde1) { // Code als voorwaarde1 true is } else if (voorwaarde2) { // Code als voorwaarde2 true is } else { // Code als geen enkele voorwaarde true is } Voorbeeld:int uur = 10; if (uur < 6) { Console.WriteLine("Goedenacht!"); } else if (uur < 12) { Console.WriteLine("Goedemorgen!"); } else if (uur < 18) { Console.WriteLine("Goedemiddag!"); } else { Console.WriteLine("Goedenavond!"); } Hier controleert het programma welk tijdstip het is en toont de juiste begroeting.
Een switch-statement is handig als je van tevoren weet welke vaste waarden een variabele kan hebben.switch (variabele) { case waarde1: // Code als variabele == waarde1 break; case waarde2: // Code als variabele == waarde2 break; default: // Code als geen enkele case overeenkomt break; } Voorbeeld:int waardeKnop = 2; switch (waardeKnop) { case 1: Console.WriteLine("Knop 1 werd ingedrukt!"); break; case 2: Console.WriteLine("Knop 2 werd ingedrukt!"); break; case 3: Console.WriteLine("Knop 3 werd ingedrukt!"); break; default: Console.WriteLine("Fout! Onbekende knop."); break; } Hier controleert het programma welke knop is ingedrukt en toont de juiste boodschap.
Gebruik if als je complexe logica hebt. Gebruik switch als je vaste waarden wilt controleren.✅ If → Voert code uit als een voorwaarde true is. ✅ Else → Voert code uit als de if-voorwaarde false is. ✅ Else if → Voegt extra voorwaarden toe. ✅ Switch → Handig als je vaste waarden wilt controleren. ✅ If vs. Switch → Gebruik if voor complexe logica, switch voor vaste waarden.In de volgende paragraaf behandelen we loops, waarmee je herhalende taken kunt uitvoeren in je code!

3.1 - Inleiding

Thu, 19 Jun 2025 08:34:12 GMT

In dit hoofdstuk schrijven we ons allereerste C#-programma. Al meer dan 50 jaar is het de onmiskenbare traditie bij het leren van een nieuwe taal om simpelweg “Hello World!” op het scherm te laten verschijnen. Wij houden die traditie in ere, en ervaren zo meteen de volledige ontwikkelcyclus: Broncode schrijven (C#) Compileren naar bytecode (Common Intermediate Language, IL) Uitvoeren: JIT (‘Just-In-Time’) in de Common Language Runtime (CLR) zet IL om in machinetaal C#-werk bestaat uit solutions (.sln) en projects (.csproj). Een solution is een container waarbinnen je één of meerdere projecten groepeert. Een project bevat je bronbestanden, referenties en bouwinstellingen, en produceert één uitvoerbaar bestand of library. Als je in Rider een “New Solution → .NET Console App” aanmaakt, genereert hij automatisch: Een MijnSolution.sln Één console-project (.csproj) Een Program.cs-bestand met een Main-methode als instappunt In de volgende paragraaf leggen we stap voor stap uit hoe je in Rider zo’n solution met console-project maakt, Program.cs opent en de klassieke Hello World-code typt: using System; class Program { static void Main(string[] args) { Console.WriteLine("Hello, World!"); } }

4.5 - Strings en Chars

Thu, 19 Jun 2025 07:54:56 GMT

Het Engelse woord string betekent een reeks van tekens. Dit kan een lange zin zijn, maar ook slechts een enkel teken, een cijfer of een symbool.Zoals we in 4.2.1 al kort zagen, noemen we elk individueel teken een char (afkorting van character). Een string is dus een reeks van chars.Voorbeeld: 'a' is een char "Hallo" is een string (een reeks van chars) Zelfs een spatie (' '), een uitroepteken ('!') of een Chinees teken ('你') zijn chars. In totaal zijn er bijna 140.000 verschillende Unicode-tekens die een computer kan herkennen!Een string is een reeks van tekens die wordt gebruikt om tekst weer te geven.string eenStringDeclareren; // Declaratie zonder waarde string eenWoord = "hallo"; // Initialisatie met een woord string eenZin = "Dit is een voorbeeldzin!"; // Initialisatie met een zin Merk op dat een string altijd tussen dubbele aanhalingstekens ("...") staat.Je kunt ook een enkel teken als string gebruiken:string enkelTeken = "A"; // Dit is een string, geen char! Een char is handig als je één enkel teken nodig hebt, maar in alle andere gevallen gebruik je een string.Meer uitleg over strings vind je op Microsoft Learn.Voordat we naar strings gaan kijken, moeten we eerst weten hoe we een char kunnen declareren en initialiseren.char eenCharDeclareren; // Declaratie zonder waarde char letterA = 'a'; // Initialisatie met een letter char cijfer5 = '5'; // Initialisatie met een cijfer char anderTeken = '>'; // Initialisatie met een symbool Merk op dat een char altijd tussen enkele aanhalingstekens ('...') staat.char getalChar = '7'; // Dit is een teken, geen cijfer! int getalInt = 7; // Dit is een cijfer, geen teken! Je kunt niet rekenen met een char, omdat de computer het als een teken ziet, niet als een getal.Soms wil je speciale tekens in een string gebruiken, zoals een nieuwe regel of een aanhalingsteken. Dit doe je met escape characters.Escape characters beginnen altijd met een backslash (\), gevolgd door een teken dat een speciale functie heeft.Voorbeeld:string tekst = "Dit is een \"quote\" binnen een string."; Console.WriteLine(tekst); Output:Dit is een "quote" binnen een string. Meer uitleg over escape characters vind je op Microsoft Docs.Je kunt meerdere strings (of strings en variabelen) samenvoegen tot één nieuwe string.✅ + operator (ouderwets) ✅ String.Format (voorloper van interpolatie) ✅ $ string interpolatie (modernste en aanbevolen methode)string uitkomst = "Mijn naam is " + naam + " en ik ben " + leeftijd + " jaar oud."; Probleem: Je moet zelf spaties toevoegen, anders worden woorden aan elkaar geplakt.string uitkomst = String.Format("Mijn naam is {0} en ik ben {1} jaar oud.", naam, leeftijd); Hier gebruiken we {0} en {1} als plaatsvervangers voor variabelen.string uitkomst = $"Mijn naam is {naam} en ik ben {leeftijd} jaar oud."; Dit is de kortste en meest intuïtieve manier!Je kunt zelfs berekeningen uitvoeren binnen string interpolatie:string uitkomst = $"Over 5 jaar ben ik {leeftijd + 5} jaar oud."; Je kunt strings netter weergeven met formattering.Voorbeeld: Afronden van een double op 2 decimalendouble getal = 35.678; Console.WriteLine($"{getal:F2}"); // Output: 35.68 De waarde van getal blijft onveranderd, maar de weergave wordt afgerond.Veelgebruikte formatteringen:Meer uitleg over string formattering vind je op Microsoft Docs.✅ Strings zijn reeksen van tekens, chars zijn individuele tekens. ✅ Chars worden tussen enkele aanhalingstekens ('...') geschreven, strings tussen dubbele aanhalingstekens ("..."). ✅ Escape characters (\n, \", \t) helpen bij speciale tekens in strings. ✅ String interpolatie ($) is de modernste manier om strings samen te voegen. ✅ Formattering (F2, D5, C) helpt bij nette weergave van getallen.In de volgende paragraaf behandelen we conditionele statements, waarmee je beslissingen kunt maken in je code!

4.4 - WriteLine en ReadLine

Thu, 19 Jun 2025 07:49:15 GMT

Wanneer we met de console werken, spreken we automatisch over input en output. Input: Gegevens die een gebruiker invoert via het toetsenbord. Output: Gegevens die de computer teruggeeft aan de gebruiker. In C# gebruiken we Console.WriteLine voor output en Console.ReadLine voor input: Wanneer je gegevens naar de console wilt schrijven, gebruik je:Console.WriteLine("Dit is een voorbeeld van output."); Console → We werken met de console. WriteLine → We schrijven een regel tekst naar de console. ("...") → De tekst die wordt weergegeven. ; → Sluit het statement af. Je kunt ook variabelen naar de console schrijven:int getal = 5; Console.WriteLine(getal); // Output: 5 In JetBrains Rider kun je cw + Tab typen om snel een Console.WriteLine(); statement te genereren!Wanneer je input van de gebruiker wilt vragen via de console, gebruik je:Console.ReadLine(); Console → We werken met de console. ReadLine → We lezen een regel tekst van de gebruiker. (); → De methode wacht tot de gebruiker op Enter drukt. Voorbeeld:Console.WriteLine("Wat is je naam?"); string naam = Console.ReadLine(); Console.WriteLine("Hallo, " + naam + "!"); Als je een getal wilt inlezen, moet je de invoer converteren:Console.WriteLine("Geef een getal:"); int getal = Convert.ToInt32(Console.ReadLine()); // Converteert string naar int Console.WriteLine("Je hebt het getal " + getal + " ingevoerd."); Andere conversies: Let op: Als een gebruiker een verkeerde invoer geeft (bijv. tekst in plaats van een getal), kan dit een fout veroorzaken (System.FormatException). Later leren we hoe we dit kunnen opvangen met foutafhandeling. Console.WriteLine en Console.ReadLine werken alleen in console-applicaties.Wanneer je later met grafische user interfaces (GUI’s) werkt, zul je ontdekken dat deze methoden niet gebruikt worden. GUI’s werken met tekstvelden, knoppen en vensters, niet met een console.Daarom is het belangrijk om Console.WriteLine en Console.ReadLine goed te leren, omdat ze essentieel zijn voor console-gebaseerde applicaties en basisprogrammering in C#.Meer uitleg over Console.ReadLine vind je op GeeksforGeeks.✅ Console.WriteLine() → Output naar de console. ✅ Console.ReadLine() → Input van de gebruiker. ✅ ReadLine geeft altijd een string terug → Gebruik Convert.ToInt32() voor getallen. ✅ Werkt alleen in console-applicaties → Niet in GUI’s.In paragraaf 4.6 behandelen we conditionele statements, waarmee je beslissingen kunt maken in je code!

3.6 - Commentaar

Thu, 19 Jun 2025 07:30:04 GMT

Commentaar is een essentieel onderdeel van programmeren. Het helpt niet alleen jezelf om te begrijpen wat je code doet, maar is ook belangrijk voor teamgenoten en leerkrachten. Goed geschreven commentaar maakt code leesbaar, onderhoudbaar en voorkomt verwarring. C# ondersteunt drie soorten commentaar: Single-line commentaar (//) Voor korte opmerkingen op één regel. Alles na // wordt genegeerd door de compiler. int getal1 = 5; int getal2 = 10; int som; // De som van getal1 en getal2 wordt berekend som = getal1 + getal2; Multi-line commentaar (/* ... */) Voor langere uitleg over meerdere regels. Alles tussen /* en */ wordt genegeerd door de compiler. /* * In onderstaande loop wordt een berekening gemaakt. * De waarde van som begint bij 15 en eindigt bij 150. */ for (int i = 0; i < 10; i++) { som += getal1 + getal2; } XML-documentatie commentaar (///) Speciaal voor het documenteren van methodes en klassen. Wordt gebruikt om automatische documentatie te genereren. ///

/// Bereken de som van twee getallen. ///

/// Eerste getal /// Tweede getal /// De som van a en b int BerekenSom(int a, int b) { return a + b; } Helpt bij debugging: Je kunt tijdelijk code uitschakelen door deze in commentaar te zetten. Maakt code begrijpelijker: Vooral bij complexe algoritmes of minder intuïtieve logica. Vergemakkelijkt samenwerking: Andere programmeurs kunnen sneller begrijpen wat je code doet. Ondersteunt onderhoud: Code die maanden later wordt aangepast, is makkelijker te begrijpen met goede commentaar. ✅ Gebruik duidelijke en relevante commentaar. ✅ Schrijf waarom iets gebeurt, niet alleen wat er gebeurt. ✅ Vermijd overbodige commentaar bij goed leesbare code. ✅ Gebruik XML-documentatie voor publieke methodes en API’s. Tip: Rider en andere IDE’s ondersteunen automatische commentaar-generatie en tonen inline documentatie bij XML-comments.

3.4 - Dotnotatie

Thu, 19 Jun 2025 07:28:52 GMT

In de regel: Console.WriteLine("Hello, World!"); valt één ding op: de punt (.) tussen Console en WriteLine. Dit is dotnotatie (ook wel puntnotatie genoemd).Dotnotatie is een manier om een methode of eigenschap van een klasse aan te roepen. In dit geval: Console is een klasse in C# die toegang geeft tot de console. WriteLine is een methode van Console die tekst naar de console schrijft. De punt (.) verbindt de klasse met de methode: Console.WriteLine(...) betekent dus “Voer de WriteLine-methode uit binnen de Console-klasse.” Oftewel: in de klasse Console staat een codeblokje (dat noemen we een methode) dat je kunt uitvoeren genaamd WriteLine. Dotnotatie wordt overal in C# gebruikt:string tekst = "Hallo"; int lengte = tekst.Length; // Lengte van de string ophalen double pi = Math.PI; // Wiskundige constante PI uit de Math-klasse Console.ForegroundColor = ConsoleColor.Green; // Tekstkleur in de console aanpassen Hier zie je dat dotnotatie niet alleen methodes (WriteLine()), maar ook eigenschappen (Length, PI, ForegroundColor) kan aanspreken.Je kunt dotnotatie interactief verkennen in Rider: Typ Console. en wacht even. Rider toont een lijst met alle beschikbare methodes en eigenschappen van Console. Gebruik de pijltjestoetsen om te navigeren en druk Enter om een methode te selecteren. Dit is een handige manier om snel te ontdekken welke functies een klasse biedt!

3.3 - Eerste code ontcijferen

Thu, 19 Jun 2025 07:27:09 GMT

Laten we nu de eerste echte regel code onder de loep nemen: Console.WriteLine("Hello, World!"); Deze regel bevat een aantal belangrijke onderdelen: Console Console is een ingebouwde klasse in C# die toegang geeft tot de console (tekstuitvoer). Hiermee kunnen we tekst weergeven, invoer verwerken en andere console-gerelateerde taken uitvoeren. WriteLine WriteLine is een methode van de Console-klasse die een tekstregel naar de console schrijft en automatisch een nieuwe regel toevoegt. Alternatief: Console.Write("Hello, World!") zou geen nieuwe regel toevoegen. ("Hello, World!") De tekst "Hello, World!" staat tussen dubbele aanhalingstekens omdat het een string is. Strings zijn tekstgegevens die in C# altijd tussen "..." staan. Later leren we variabelen gebruiken om dynamisch tekst te tonen. ; (puntkomma) De puntkomma (;) sluit het statement af. Vergelijk het met een punt aan het einde van een zin: het markeert het einde van een instructie. In C# is een puntkomma verplicht na elke losse instructie. Je kunt Console.WriteLine ook gebruiken met variabelen en speciale tekens:string naam = "Alice"; Console.WriteLine("Hallo, " + naam + "!"); // Tekst combineren Console.WriteLine("Dit is een nieuwe regel.\nEn nog een."); // \n voor een nieuwe regel Console.WriteLine($"Hallo, {naam}!"); // String interpolatie (vanaf C# 6.0), ter vervanging van het + teken om strings te combineren In de hoofdstuk 4 gaan we dieper in op variabelen, datatypes en hoe je dynamisch tekst kunt genereren in C#.

3.2 - Solution en project aanmaken

Thu, 19 Jun 2025 07:26:21 GMT

Voordat je begint met coderen werk je altijd in een solution en een project. In Rider kun je dit in één handeling aanmaken, inclusief een kant-en-klaar “Hello World!”-voorbeeld. Hoewel je code in Kladblok kunt typen, mis je: Automatische syntax-kleuring Intellisense (autocomplete) Foutcontrole (live errors) Eén-klik build en debug Daarom gebruiken we JetBrains Rider, een krachtige .NET-IDE. Start Rider en kies in het welkomstscherm voor New Solution. In de template-lijst selecteer je onder .NET / .NET Core → Console Application Let op: niet onder .NET Framework kiezen. Vul in het rechterpaneel: Solution name: OpdrachtX_Naam (geef je opdracht een duidelijke naam) Project name: wordt automatisch overgenomen, maar je kunt het aanpassen Solution directory: navigeer naar je OneDrive → 5IB\Informatica\Programmeren\… Target framework / SDK: kies voor de laatst geïnstalleerde .NET versie Vink Do not use top level statements aan Klik Create. Rider genereert nu: OpdrachtX_Naam.sln (solution-bestand) Eén console-projectmap met .csproj en Program.cs Na aanmaak zie je in de Explorer-toolwindow: Dependencies bevat je referenties en NuGet-packages Program.cs bevat de Main-methode met een standaard “Hello World!”-template Je programma runt altijd vanuit je Program.cs en je Main-methode! Later in de cursus komen nog uitgebreid terug op wat een methode is! Klik rechtsboven op de groene ▶-knop (of druk Shift+F10). Rider compileert je code (IL → JIT) en opent de Run-console onderin. Je ziet: Hello, World! Process finished with exit code 0. Gefeliciteerd: je eerste C#-programma draait en toont tekst in de console! In de volgende paragrafen ontleden we elke regel in Program.cs en leer je hoe je dit uitgangspunt uitbreidt.

2.2 - Rider en Toolbox

Thu, 19 Jun 2025 07:23:37 GMT

De JetBrains Toolbox App is een kleine hulpprogramma-manager waarmee je eenvoudig al je JetBrains-IDE’s (Rider, PHPStorm, DataGrip, …) installeert, bijwerkt en verwijdert zonder elke keer naar de website te gaan. Centrale plek voor al je IDE’s en tools Automatische updates: blijf altijd op de meest recente release of kies LTS/EAP Versiebeheer: installeer meerdere versies naast elkaar (stable, preview, EAP) Licentie- en accountbeheer geïntegreerd Snel schakelen tussen producten en projecten Ga naar https://www.jetbrains.com/toolbox-app/ en klik op Download. Kies het juiste installatiebestand voor jouw OS: Windows (.exe) macOS (.dmg, Intel of Apple Silicon) Linux (.tar.gz) Voer het installatiebestand uit en doorloop de wizard (Windows) of sleep de app naar Applicaties (macOS). Na installatie draait Toolbox als klein icoon in je system tray (Windows/Linux) of menubalk (macOS). Klik op het Toolbox-icoon en log in met je JetBrains-account (Student-, Edu- of betaalde licentie). In het overzicht zie je alle beschikbaar IDE’s. Filter eventueel op “Rider” of zoek in de lijst. Zoek in Toolbox naar Rider, klik op Install. Kies voor Stable Release (dit is de laatste stabiele versie van Rider). Optioneel: stel custom installatielocatie en toolchain-paden in via het tandwiel-icoon. Klik Install en wacht tot download en installatie voltooid zijn. Open Rider via Toolbox of via je startmenu/launchpad. Kies Do not import settings bij eerste installatie (of Import previous settings als je al eerder hebt gewerkt). In de wizard kan je kiezen voor een bepaald kleurenschema. Dit is een persoonlijke keuze. Je mag dit nu ook overslaan, aangezien je dit later nog kan wijzigen. Sla de wizard voor plugins voorlopig ook over, of vink direct gewenste C#-plugins aan. Meld je aan met je JetBrains-account om je licentie te activeren. Nu staat Rider klaar voor je eerste C#-project! Dankzij Toolbox installeer je later moeiteloos andere JetBrains-IDE’s en blijf je altijd up-to-date.

1.6 - .NET

Thu, 19 Jun 2025 07:20:57 GMT

.NET (uitspraak “dotnet”) is een framework van Microsoft dat applicaties en bibliotheken naadloos laat samenwerken. Je kunt het zien als een woordenboek en draaitijdomgeving die de betekenis van C#-code (en andere .NET-talen) vertaalt naar instructies voor de processor. Hoewel .NET van origine een Windows-technologie is, bestaat er nu één uniform platform dat op Windows, macOS en Linux draait. Tegenwoordig spreken we simpelweg over .NET, de opvolger van .NET Core, dat weer de opvolger is van het klassieke .NET Framework. Een framework is een herbruikbare structuur (code-bibliotheken, API’s, tools, conventies) waarmee ontwikkelaars sneller én consistenter software kunnen bouwen—of dat nu een webapplicatie, desktopprogramma of cloud-service is. 1.6.1 – Wat is .NET Framework? Gelanceerd in 2002 als Windows-only framework. Ondersteunde aanvankelijk Visual Basic en het pas ontwikkelde C# voor zowel desktop- (WinForms, WPF) als web-ontwikkeling (ASP.NET Web Forms, later MVC) 3^. Volledig geïntegreerd in Windows: één monolithische runtime, system-level API’s en Visual Studio-integratie. Laatste major versie: .NET Framework 4.8. Onderhoud (security-updates) blijft, maar er komen geen grote nieuwe features meer. 1.6.2 – Wat is .NET Core? Gelanceerd in 2016 als volledig herbouwd, open-source en cross-platform framework 2^4^. Modulaire opbouw: je voegt via NuGet alleen de onderdelen toe die je nodig hebt (bijv. ASP.NET Core, Entity Framework Core). Draait op Windows, Linux en macOS; ook geschikt voor Docker-containers en microservices. Lichtgewicht, hoge performance en command-line tooling (CLI) voor build, test en deployment. 1.6.3 – Wat is .NET Standard? Een API-contract (bibliotheekspecificatie) uit 2016 dat code-deling tussen .NET Framework, .NET Core en Xamarin mogelijk maakte 2^. Doel: schrijf je library tegen .NET Standard x.y, dan kan die op alle .NET-implementaties draaien die dat Standard-niveau ondersteunen. 1.6.4 – Wat is .NET 5 en later? Vanaf .NET 5 (2020) is .NET Core hernoemd naar “.NET” – een unified platform voor desktop, web, cloud, mobiele apps, IoT en meer 2^. .NET 6 (LTS-versie, november 2021) en .NET 7 (kortcyclisch) brengen elke 12 maanden nieuwe features, prestatieverbeteringen en taalversies (C# 10, C# 11, …). Modern SDK-model: één CLI (dotnet), één runtime, één set basis-API’s en één NuGet-ecosysteem. Kort samengevat: .NET Framework = Windows-only, monolithisch, in onderhoud, laatste versie 4.8. .NET Core = open source, modulair, cross-platform, opgegaan in “.NET” vanaf versie 5. .NET Standard = API-contract voor code-deling tussen verschillende .NET-implementaties. .NET 5+ = het moderne, uniforme .NET-platform voor álle soorten applicaties. De laatste LTS-release van .NET is een uitstekende keuze voor nieuwe projecten. Voor elk type applicatie (desktop, web, mobile, cloud) is er nu één ecosysteem, één CLI en één runtime die jouw C#-code vertaalt en optimaliseert voor het onderliggende besturingssysteem en de hardware.

1.7 - Probleemoplossend denken

Thu, 19 Jun 2025 07:16:21 GMT

Programmeren start nooit zomaar met code—je hebt altijd een doel of een probleemstelling. Probleemoplossend denken (of computational thinking) helpt je om systematisch van idee naar werkende applicatie te gaan. Decompositie – Breek een groot probleem op in kleinere, behapbare deelproblemen. – Bijvoorbeeld: een rekenmachine-app kun je opdelen in invoer, rekenlogica, weergave en foutafhandeling. Patroonherkenning – Zoek terugkerende processen of overeenkomsten tussen deelproblemen. – Kun je code hergebruiken of logica modulair maken? Abstractie – Negeer onnodige details; focus op de essentie van elk deelprobleem. – Definieer een interface of pseudocode vóór je écht gaat coderen. Algoritmeontwerp – Schrijf in woorden of flow-diagrammen een stap-voor-stap recept uit om elk deelprobleem op te lossen. – Denk aan sorteer-, zoek- of berekeningsstrategieën. Probleemstelling: Wat is feitelijk het probleem? Welke functionaliteit moet er zijn? ↓ Probleemanalyse & ontwerp: Analyse: Welke inputs, outputs en randgevallen bestaan er? Design: Maak flowcharts, UML-klassendiagrammen of pseudocode. Data- en taakstructuur: Bepaal datastructuren (lijsten, objecten, klassen) en onderverdeling in modules. ↓ Coderen: Schrijf je code in de gekozen taal volgens je ontwerp. ↓ Testen & debuggen: Unit tests: Test kleine stukjes code automatisch. Integratietests: Controleer of modules samenwerken. Debuggen: Gebruik breakpoints, logging en “rubber-duck debugging” om fouten (‘bugs’) op te sporen. ↓ Refactoren & optimaliseren: Pas code aan: vereenvoudig, verwijder duplicaten of verbeter performance. Herhaal testen & debuggen totdat alles werkt én onderhoudbaar is. ↓ Compileren / builden: Maak een uitvoerbaar bestand, package of deployment-artifact klaar voor gebruik. De meeste inspanning gaat naar ontwerp, testen/debuggen en refactoren. Goede planning en kleine iteraties (bijvoorbeeld via test-driven development) besparen je later veel frustratie. Schrijf eerst pseudocode of een flowchart; coderen gaat daarna sneller. Documenteer aannames en randgevallen (edge cases) voordat je begint. Gebruik versiebeheer (Git): commit je werk in logische stapjes. Automatiseer herhalende tests (CI/CD-pipelines). Hang niet te lang vast: maak een simpele “proof of concept” en breid langzaam uit. Leer omgaan met complexe algoritmes (divide-and-conquer, greedy, dynamisch programmeren). Probleemoplossend denken is de kern van programmeren: je leert het niet door alleen te lezen, maar door te ontwerpen, coderen, testen, debuggen én herhalen. Veel succes!

1.5 - Compiler

Thu, 19 Jun 2025 06:59:46 GMT

Een compiler is een vertaalprogramma dat broncode in een hogere programmeertaal omzet naar machinetaal (of naar een tussentaal). Zo kun je in C#, Java of C++ schrijven en uiteindelijk toch een uitvoerbaar bestand (.exe, .dll, .class, …) laten draaien op een computer die alleen 0/1-instructies begrijpt. Lexicale analyse Knipt de tekst op in stukjes (tokens): sleutelwoorden, identifiers, operatoren, literalen. Syntactische analyse Bouwt uit die tokens een parse-tree of abstract syntax tree (AST) volgens de grammatica van de taal. Semantische analyse Controleert types, scope, naamresolutie en andere regels (“Is dit een geldig statement?”). Optimalisatie Verbetert de tussenrepresentatie (bijv. lussen ontdubbelen, overbodige berekeningen verwijderen). Codegeneratie Zet de geoptimaliseerde tussenrepresentatie om in doelcode: machinecode voor een bepaalde processor, of een intermediate language (IL). Linken (optioneel) Combineert meerdere object- of library-bestanden tot één uitvoerbaar bestand of assembly. Ahead-of-Time (AOT) compilatie De broncode wordt volledig gecompileerd vóór de uitvoering. C en C++ → native binaire executables (.exe/.out) + statische of dynamische libraries. Interpreter Leest en voert broncode regel-voor-regel uit tijdens runtime. Python en JavaScript zijn hoofdzakelijk geïnterpreteerd, al bestaan er JIT-versnellers. Hybride modellen (bytecode + JIT) Java → broncode ⇒ Java-compiler ⇒ bytecode (.class) ⇒ JVM laadt bytecode ⇒ Just-In-Time compiler ⇒ native code. C#/.NET → broncode ⇒ Roslyn compiler ⇒ Common Intermediate Language (CIL/MSIL, .dll/.exe) + metadata ⇒ CLR-loader ⇒ JIT ⇒ native code. C#-code wordt gecompileerd naar CIL (Common Intermediate Language), verpakt in een assembly (.dll of .exe) met metadata (type-informatie, methodesignatures, versies). De Common Language Runtime (CLR) laadt die assembly, voert beveiligingschecks uit en compileert – via de JIT-compiler – alleen de uitgevoerde methodes naar native instructies. Voordelen Eén binaire assembly draait op Windows, macOS en Linux (mits .NET-runtime geïnstalleerd). Cross-language interoperabiliteit: VB.NET, F#, C# en toekomstige .NET-talen delen dezelfde IL. AOT-opties Met tools als ReadyToRun, NativeAOT of ngen kun je IL vooraf omzetten naar native code voor snellere opstart en beperkte runtime-afhankelijkheden. Portabiliteit: de programmeur levert één IL-bestand, de runtime verzorgt de juiste machinecode voor elk platform. Optimalisatie: compile-time en runtime (JIT-profiling) kunnen samenwerken om je code sneller te maken. Veiligheid en beheerd geheugen: de CLR zorgt voor sandboxing, type-veiligheid en automatische garbage-collection, waardoor veelvoorkomende fouten (buffer-overflows, null refs) grotendeels vermeden worden. Desktopapps WinForms, WPF, MAUI: traditionele GUI-programma’s op Windows, macOS en Linux. Games Unity (C#-scripting) en andere engines, naast C++ nog steeds toonaangevend in game-ontwikkeling. Cloud-native apps Microservices en serverless functies met ASP.NET Core, Docker-containers en Kubernetes. Webservices & backend REST- en gRPC-API’s, data-access via Entity Framework, koppelingen met relationele en NoSQL-databases.

1.4 - Objecten en OOP

Thu, 19 Jun 2025 06:57:00 GMT

In objectgeoriënteerd programmeren (OOP) bouw je je applicatie op uit ‘objecten’ die samenwerken. Een object is een representatie van iets uit de echte wereld – je kunt er eigenschappen (state) en gedrag (methods) aan koppelen.– Klasse versus object • Een klasse is het blauwdruk-concept: je beschrijft wélke eigenschappen (velden of “properties”) en welk gedrag (methoden) elk object ervan heeft. • Een object (ook wel “instantie”) is een concreet exemplaar van die klasse. Bijvoorbeeld: – Klasse Schoenveter → attributen: kleur, lengte; methoden: StrikMaken() – Object veter1 = new Schoenveter(“rood”, 120 cm)– Vier pijlers van OOP Encapsulatie: bundel data en functies én schakel onnodige internals uit met public/private. Abstractie: verberg complexe implementatie, toon alleen wat nodig is (interface). Overerving (inheritance): laat een nieuwe klasse (subklasse) eigenschappen en gedrag van een bestaande klasse (superklasse) overnemen én uitbreiden. Polymorfisme: behandel objecten van verschillende klassen via één gemeenschappelijke interface, met elk hun eigen uitvoering (overriding/overloading). Later in de cursus duiken we uitgebreider in: hoe schrijf je klassen, maak je objecten aan, werk je met constructors, property getters/setters, interfaces en abstracte klassen.C# is vanaf het begin ontworpen als moderne, objectgeoriënteerde taal binnen het .NET-framework. Hieronder lees je waarom we ermee aan de slag gaan: Volledig OOP – C# dwingt je om te denken in objecten én ondersteunt ook structuren, generics en uitbreidingen via extension methods. Robuuste tooling – JetBrains Rider (of Microsoft Visual Studio) biedt Intellisense, refactoring-tools, visuele designers en een krachtige debugger. Typeveilig en beheerd geheugen – Dankzij sterke types en automatische garbage collection voorkom je veelvoorkomende fouten (null-refs, geheugenlekken). Rijke klassebibliotheek (.NET BCL) – Van bestands- en netwerk-I/O tot GUI-frameworks (WinForms, WPF, MAUI) en web-API’s (ASP.NET), voor zowat elke toepassing is er een kant-en-klare library. Cross-platform & ecosysteem – .NET Core/.NET 6+ draait op Windows, macOS en Linux. Via NuGet installeer je eenvoudig duizenden open-source pakketten. Multi-paradigma – Naast OOP ondersteunt C# ook functionele stijlen (LINQ, immutability, lambdas) en asynchrone programmeren (async/await). Grote community & documentatie – Tutorials, voorbeeldprojecten, StackOverflow-antwoorden en officiële Microsoft Docs vind je in overvloed. Tip om te starten Het belangrijkste? Ga met code experimenteren. Bouw kleine projectjes—een rekenmachine, een to-do-app of een mini-game. Zo ontdek je zelf hoe klassen samenwerken, wat overerving oplevert en hoe polymorfisme je code flexibel maakt. Veel programmeerplezier!

1.1 - Wat is programmeren

Thu, 19 Jun 2025 06:52:26 GMT

Laten we eerst kijken naar wat een programmeertaal eigenlijk is, waarom het zo belangrijk is binnen informatica en waarom dat programmeren hét belangrijkste onderdeel is binnen softwareontwikkeling. Kort gezegd: programmeren is eigenlijk niks meer dan instructies geven aan de computer. De computer voert vervolgens deze instructies uit. Er zijn programmeertalen die heel dicht bij ‘mensentaal’ liggen (high-level talen), maar er zijn ook programmeertalen die zeer abstract zijn (low- level talen). Welke programmeertaal je ook leert of gebruikt, alle instructies kunnen maar op één manier door de computer worden ‘begrepen’. Elke programmeertaal wordt tevens omgezet in machinetaal. Dit is een set van directe instructies aan de processor. Misschien ken je dit van ziens al wel, want het bestaat volledig uit enen en nullen. Machinetaal is daarmee eigenlijk de meest low-level taal. Een groot nadeel van machinetaal is dat de instructies van verschillende processoren vaak niet overeenkomen, waardoor het nodig is om software volledig te herschrijven wanneer een gebruiker een andere processor heeft dan de programmeur waar de software mee geschreven is. Je kunt dit vergelijken met iemand die een boek heeft geschreven in een taal die jij niet kan lezen. Dit is vanaf de jaren ’90 geleidelijk aan opgelost doordat high-level talen hier rekening mee konden gaan houden. Nu konden programmeurs steeds gemakkelijker software ontwikkelen ongeacht welke processor de eindgebruiker had. Ook begon het besturingssysteem van de eindgebruiker steeds minder van belang te zijn. Vandaag de dag is een taal als Java zeer veelzijdig en kan het gebruikt worden om software te ontwikkelen voor Windows, Android, MacOS, Linux, … ongeacht welke processor de eindgebruiker heeft. Hoewel C# vaak wordt ingedeeld als high-level taal, is het eigenlijk een mid-level taal: zeer krachtig maar toch relatief simpel te leren.
De grammatica van de code die we gaan schrijven noemen we syntaxis (in het Engels syntax, de Nederlandse en Engelse woorden worden vaak door elkaar gebruikt). Dit zijn dus eigenlijk de taalregels binnen elke programmeertaal. Code in C# wordt anders geschreven dan code in de taal BASIC. Dit heeft dus alles te maken met de syntax. Vrijwel alle belangrijke programmeertalen zijn gebaseerd op de Engelse taal. High-level talen proberen om het Engels zo duidelijk mogelijk na te bootsen, waardoor het voor ons gemakkelijker wordt om de taal te leren en de code gemakkelijker te lezen is.

1.2 - IDE

Thu, 19 Jun 2025 06:51:32 GMT

Software wordt tegenwoordig altijd in een IDE ontwikkeld. IDE staat voor Integrated Development Environment. Dit is eigenlijk een programma dat je op je computer installeert waarmee je zelf code kunt schrijven en daardoor applicaties kunt ontwikkelen. Een IDE heeft een grafische interface wat het schrijven van code vergemakkelijkt. Ook zijn debuggers, automation tools, e.d. vaak ingebouwd. Hier zijn verschillende mogelijkheden in: je hebt zowel gratis IDE’s, als IDE’s waar je voor moet betalen. Deze laatste hebben dan vaak meer functionaliteit en betere ondersteuning door de ontwikkelaars. Wij gaan de komende twee jaar gebruiken maken van Rider van het bedrijf JetBrains. Rider is momenteel de meest complete, meest robuuste (en eigenlijk daarmee ook de beste) IDE voor het maken van applicaties in C#. Ontwikkelaar JetBrains is één de marktleiders op het gebied van IDE's. Voor het vak webdevelopment gaan we dan ook gebruik maken van een IDE van JetBrains, namelijk WebStorm of PhpStorm. Ook voor het vak databases maken we gebruik van een IDE van JetBrains, te weten DataGrip. Zoals je wel merkt, heeft JetBrains voor vrijwel elke situatie als softwareontwikkelaar een oplossing! Helaas zijn de producten van JetBrains zeer prijzig (denk aan minimum €600 per jaar voor een licentie om hun software te mogen gebruiken...), maar gelukkig is het voor hogescholen en universiteiten die (toegepaste) informatica als opleiding hebben gratis. Ook voor ons, als 3e graad Informaticabeheer is het volledige pakket van JetBrains gratis! Daar moetenwe natuurlijk gebruik van maken! In het volgende hoofdstuk komen we hier op terug en gaan we alle benodigde software installeren en configureren. Er zijn weliswaar enkele gratis IDE's beschikbaar (waaronder Visual Studio van Microsoft), maar aangezien wij sowieso gebruik gaan maken van de software van Jetbrains, gebruiken we in ons geval gewoon Rider.

10.1 - Inleiding

Sat, 14 Jun 2025 06:27:18 GMT

In softwareontwikkeling zijn testing en debugging twee essentiële processen die zorgen voor kwaliteit en betrouwbaarheid.✅ Debugging Doel: Identificeren en corrigeren van fouten in de code. Technieken: Handmatige inspectie, interactive debugging, remote debugging. ✅ Testing Doel: Valideren van functionaliteit en prestaties. Soorten: Unit testing, integration testing, system testing. Beide processen zorgen ervoor dat software voldoet aan vereisten en verwachtingen van eindgebruikers.✅ Waarom is debugging cruciaal? Voorkomt crashes en bugs in productie. Verhoogt softwarekwaliteit en gebruikerservaring. ✅ Waarom is testing essentieel? Valideert of de software werkt zoals verwacht. Helpt bij detectie van fouten vóór de release. ✅ Debugging en testing verbeteren softwarekwaliteit en betrouwbaarheid. ✅ Debugging corrigeert fouten, testing valideert de functionaliteit. ✅ Gebruik best practices en tools om efficiënter te werken.

9.4 - CREATE

Fri, 13 Jun 2025 21:03:33 GMT

Wanneer we werken met een helper klasse, zoals DbConnection, wordt het maken van een nieuwe tabel in MS SQL Server eenvoudig.✅ We gaan een SQL CREATE TABLE-statement uitvoeren binnen C# met Microsoft.Data.SqlClient.✅ Gebruik een helper klasse om een tabel efficiënt te maken in MS SQL Server.using System; using Microsoft.Data.SqlClient; class Program { static void Main(string[] args) { string createTableStatement = @" CREATE TABLE Students ( StudentID INT PRIMARY KEY, FirstName NVARCHAR(50), LastName NVARCHAR(50), EnrollmentDate DATE )"; DbConnection.ExecuteCMD(createTableStatement); Console.WriteLine("Table 'Students' created successfully."); } } ✅ Hier maken we een tabel genaamd Students met de volgende kolommen: StudentID (INT, PRIMARY KEY) FirstName (NVARCHAR(50)) LastName (NVARCHAR(50)) EnrollmentDate (DATE) ✅ MS SQL Server ondersteunt geen CREATE TABLE IF NOT EXISTS zoals MySQL, dus we moeten eerst controleren of de tabel al bestaat.using System; using Microsoft.Data.SqlClient; class Program { static void Main(string[] args) { string createTableIfNotExistsStatement = @" IF NOT EXISTS (SELECT * FROM opdrachten.INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'Students' AND TABLE_SCHEMA = 'dbo') BEGIN CREATE TABLE Students ( StudentID INT PRIMARY KEY, FirstName NVARCHAR(50), LastName NVARCHAR(50), EnrollmentDate DATE ) END"; DbConnection.ExecuteCMD(createTableIfNotExistsStatement); Console.WriteLine("Table 'Students' created successfully if it did not already exist."); } } ✅ Hier controleren we of de tabel Students al bestaat voordat we deze aanmaken. ✅ Het statement IF NOT EXISTS gebruikt INFORMATION_SCHEMA.TABLES om te controleren of de tabel aanwezig is.❗ BELANGRIJK: Pas de juiste database en schema (opdrachten en dbo) aan naar jouw omgeving! Indien een andere database wordt gebruikt, wijzig de TABLE_SCHEMA naar de juiste waarde. ✅ Gebruik IF NOT EXISTS als: Je wilt voorkomen dat een fout optreedt wanneer de tabel al bestaat. Je applicatie robuuster wilt maken en dubbele tabellen wilt vermijden. Je meerdere keren een CREATE TABLE wilt uitvoeren zonder fouten. ✅ Gebruik CREATE TABLE om nieuwe tabellen aan te maken binnen MS SQL Server. ✅ Gebruik IF NOT EXISTS om te controleren of de tabel al bestaat voordat je deze aanmaakt. ✅ Gebruik een helper klasse (DbConnection) om SQL-opdrachten efficiënt uit te voeren. ✅ Test altijd of de CREATE TABLE-query correct werkt en geen fouten veroorzaakt.

7.1 - Constructors

Fri, 13 Jun 2025 18:45:57 GMT

Wanneer we met overerving gaan werken, moeten we ook kijken naar hoe constructors werken.Dit is niet altijd vanzelfsprekend!Wanneer je een childklasse instantieert, gebeurt het volgende: ✅ Eerst wordt de constructor van de parentklasse uitgevoerd. ✅ Daarna wordt de constructor van de childklasse uitgevoerd.class Soldaat { public Soldaat() { Console.WriteLine("Soldaatobject is aangemaakt!"); } } class Veldarts : Soldaat { public Veldarts() { Console.WriteLine("Veldartsobject is aangemaakt!"); } } Veldarts arts = new Veldarts(); Output:Soldaatobject is aangemaakt! Veldartsobject is aangemaakt! ✅ Eerst wordt de constructor van de parentklasse uitgevoerd (Soldaat). ✅ Daarna wordt de constructor van de childklasse uitgevoerd (Veldarts).Wanneer je een constructor in een childklasse maakt, wordt achter de schermen altijd : base() toegevoegd.✅ Dit zorgt ervoor dat de constructor in de parentklasse wordt aangeroepen. ✅ Je kunt parameters doorgeven aan de constructor van de parentklasse.class Soldaat { public Soldaat(bool kanSchieten) { Console.WriteLine($"Soldaat aangemaakt - Kan schieten: {kanSchieten}"); } } class Veldarts : Soldaat { public Veldarts() : base(true) // Altijd "true" doorgeven aan de parentklasse { Console.WriteLine("Veldartsobject is aangemaakt!"); } } Veldarts arts = new Veldarts(); Output:Soldaat aangemaakt - Kan schieten: True Veldartsobject is aangemaakt! ✅ Hier wordt altijd true doorgegeven aan de constructor van Soldaat. ✅ Je kunt base() aanpassen om verschillende waarden door te geven (zie constructor overloading hieronder).✅ Gebruik constructor overloading als je flexibel verschillende waarden wilt doorgeven aan de parentklasse.class Soldaat { public Soldaat(bool kanSchieten) { Console.WriteLine($"Soldaat aangemaakt - Kan schieten: {kanSchieten}"); } } class Veldarts : Soldaat { // Overloaded constructor - waarde kan dynamisch worden meegegeven public Veldarts(bool kanSchieten) : base(kanSchieten) { Console.WriteLine($"Veldarts aangemaakt - Kan schieten: {kanSchieten}"); } // Default constructor met vaste waarde "true" public Veldarts() : base(true) { Console.WriteLine("Veldartsobject is aangemaakt!"); } } Veldarts arts1 = new Veldarts(); // Default: Kan schieten = true Veldarts arts2 = new Veldarts(false); // Overloaded: Kan schieten = false Output:Soldaat aangemaakt - Kan schieten: True Veldartsobject is aangemaakt! Soldaat aangemaakt - Kan schieten: False Veldarts aangemaakt - Kan schieten: False ✅ Hier kunnen we kiezen of de Veldarts kan schieten of niet. ✅ De eerste variant gebruikt de default waarde (true). ✅ De tweede variant laat ons zelf een waarde kiezen (false).✅ Eerst wordt de constructor van de parentklasse uitgevoerd, daarna die van de childklasse. ✅ Gebruik base() om de constructor van de parentklasse aan te roepen. ✅ Je kunt base() gebruiken om waarden door te geven aan de parentklasse. ✅ Gebruik constructor overloading om flexibiliteit toe te voegen. ✅ Dit helpt om minder code te dupliceren en een betere structuur te creëren.

4.8 - Random

Thu, 12 Jun 2025 14:09:33 GMT

Het is mogelijk om op een simpele manier willekeurige getallen te genereren in C#. Dit is handig voor bijvoorbeeld games, simulaties of testen.In C# gebruiken we de Random-klasse om willekeurige getallen te genereren.Meer uitleg over Random vind je op Microsoft Learn.Om een willekeurig getal te genereren, moeten we twee stappen volgen: Maak eenmalig een Random-object aan Gebruik dat object telkens als je een nieuw willekeurig getal wilt Random randomGenerator = new Random(); // Maak een Random-object aan int willekeurigGetal = randomGenerator.Next(); // Genereer een willekeurig geheel getal Console.WriteLine(willekeurigGetal); Hier wordt een willekeurig geheel getal gegenereerd en gekoppeld aan de variabele willekeurigGetal.Je kunt meerdere willekeurige getallen genereren:int getal1 = randomGenerator.Next(); int getal2 = randomGenerator.Next(); int getal3 = randomGenerator.Next(); Console.WriteLine(getal1); Console.WriteLine(getal2); Console.WriteLine(getal3); Elke keer dat Next() wordt aangeroepen, wordt een nieuw willekeurig getal gegenereerd.Je kunt een bereik instellen voor het willekeurige getal door argumenten mee te geven aan Next().Random generator = new Random(); int a = generator.Next(0, 11); // Getal tussen 0 en 10 int b = generator.Next(55, 100); // Getal tussen 55 en 99 int c = generator.Next(0, b); // Getal tussen 0 en b - 1 Console.WriteLine(a); Console.WriteLine(b); Console.WriteLine(c); Let op: Het maximum ligt altijd één lager dan de opgegeven waarde! Tot nu toe hebben we gehele getallen gegenereerd met Next().Voor kommagetallen gebruiken we NextDouble().Random rand = new Random(); double randomKommaGetal = rand.NextDouble(); // Getal tussen 0.0 en 1.0 Console.WriteLine(randomKommaGetal); Hier wordt een willekeurig kommagetal gegenereerd tussen 0.0 en 1.0.Wil je een groter bereik? Vermenigvuldig het resultaat:double randomKommaGetal = rand.NextDouble() * 10; // Getal tussen 0.0 en 10.0 Console.WriteLine(randomKommaGetal); Wil je een specifiek bereik (bijv. tussen 5.0 en 12.5)?double randomKommaGetal = 5 + (rand.NextDouble() * 7.5); Console.WriteLine(randomKommaGetal); Hier wordt het bereik 7.5 (12.5 - 5.0) vermenigvuldigd met NextDouble(), en daarna 5 opgeteld om het bereik te verschuiven.✅ Random.Next() → Genereert een willekeurig geheel getal. ✅ Random.Next(min, max) → Genereert een willekeurig geheel getal binnen een bereik. ✅ Random.NextDouble() → Genereert een willekeurig kommagetal tussen 0.0 en 1.0. ✅ Bereik aanpassen → Vermenigvuldig NextDouble() om een groter bereik te krijgen.

4.3 - Operatoren

Thu, 12 Jun 2025 13:47:31 GMT

Een operator in C# is een symbool dat een bewerking uitvoert op één of meerdere variabelen. We onderscheiden drie grote groepen operatoren:✅ Wiskundige operatoren (+, -, *, /, %) ✅ Logische operatoren (&&, ||, !) ✅ Vergelijkingsoperatoren (>, <, ==, !=, >=, <=)Daarnaast hebben strings een speciale operator (+) waarmee je meerdere strings kunt samenvoegen. Dit behandelen we later in het hoofdstuk over strings.Deze operatoren voeren rekenkundige bewerkingen uit op numerieke variabelen.Deze operatoren worden gebruikt om een waarde toe te wijzen aan een variabele.Vergelijkingsoperatoren worden gebruikt om twee waarden met elkaar te vergelijken. Ze geven altijd een boolean (true of false) als resultaat.Logische operatoren worden gebruikt om booleaanse waarden (true of false) te combineren.Sommige operatoren hebben een hogere prioriteit dan andere. Bijvoorbeeld:int resultaat = 10 + 5 * 2; Console.WriteLine(resultaat); // Output: 20 Hier wordt eerst 5 * 2 berekend (10), en daarna pas 10 + 10 (20).Je kunt haakjes gebruiken om de volgorde te wijzigen:int resultaat = (10 + 5) * 2; Console.WriteLine(resultaat); // Output: 30 ✅ Wiskundige operatoren voeren berekeningen uit (+, -, *, /, %). ✅ Toewijzingsoperatoren wijzigen de waarde van een variabele (+=, -=, *=, /=). ✅ Vergelijkingsoperatoren vergelijken twee waarden (==, !=, >, <). ✅ Logische operatoren combineren booleaanse waarden (&&, ||, !). ✅ Operatorprioriteit bepaalt de volgorde van berekeningen.In de volgende paragraaf behandelen we conditionele statements, waarmee je beslissingen kunt maken in je code!

4.0 - Inleiding

Thu, 12 Jun 2025 13:28:51 GMT

In het vorige hoofdstuk heb je je eerste programma in C# geschreven. Hoewel het slechts tekst op het scherm toonde, was dit een belangrijke eerste stap. Nu gaan we verder met de fundamentele concepten van programmeren. Om effectief te programmeren in C# (of een andere objectgeoriënteerde programmeertaal), moet je abstract leren denken. Dit betekent dat je kijkt naar de belangrijkste eigenschappen en gedragingen van een object en deze vastlegt in code. Bijvoorbeeld: alle auto’s hebben gemeenschappelijke kenmerken: Ze hebben een motor Ze verbruiken brandstof Ze kunnen rijden Ze hebben verlichting en zitplaatsen Deze overeenkomsten vormen de basis voor een klasse (class). Vanuit deze klasse kunnen we objecten (objects) maken, zoals een specifieke auto met een bepaald merk, kleur en aantal deuren. Alle OOPL’s (Object-Oriented Programming Languages) volgen bepaalde regels: Code wordt van boven naar beneden en van links naar rechts gelezen. Statements eindigen meestal met een puntkomma (;). Code wordt gestructureerd in methoden, klassen en objecten. Variabelen worden gebruikt om gegevens op te slaan en te manipuleren. In dit hoofdstuk behandelen we de basis van C# en leren we wat algoritmes zijn. Onderwerpen die aan bod komen: ✅ Variabelen (variables) en constanten (constants) ✅ Bewerkingen (operators) zoals optellen, aftrekken en vergelijken ✅ Conditionele statements (conditionals) zoals if, else en switch ✅ Lussen (loops) zoals for, while en foreach ✅ Klassen (classes) en objecten (objects) ✅ Methoden (methods) en hoe je ze aanroept ✅ Uitdrukkingen (statements) en hoe ze worden uitgevoerd ✅ Code-blokken (code blocks) en hun bereik ✅ Programmeerregels en attitudes voor gestructureerde en efficiënte code ✅ Instructies voor het verloop van je programma Door deze basisprincipes te begrijpen, kun je steeds complexere programma’s bouwen. Laten we beginnen met het eerste fundamentele concept: variabelen en datatypes!

3.5 - Puntkomma

Thu, 12 Jun 2025 13:19:45 GMT

In de regel: Console.WriteLine("Hello, World!"); valt nog een specifiek teken op: de puntkomma (;).Een puntkomma (;) markeert het einde van een statement in C#. Vergelijk het met een punt aan het einde van een zin: het geeft aan dat de instructie compleet is. Na een statement: int leeftijd = 25; Console.WriteLine(leeftijd); Hier sluiten we zowel de variabele-toewijzing (int leeftijd = 25;) als de Console.WriteLine-instructie af met een puntkomma. Bij meerdere statements op één regel: int a = 5; int b = 10; Console.WriteLine(a + b); Dit is toegestaan, maar minder leesbaar. Bij blokken met accolades {} if (leeftijd >= 18) { Console.WriteLine("Je mag stemmen!"); } Hier sluiten we het if-statement niet af met een puntkomma, omdat het een codeblok bevat. Bij methodedefinities: void ToonBericht() { Console.WriteLine("Welkom!"); } De methode ToonBericht() krijgt geen puntkomma na de {}, omdat het een blok vormt.Vergeten puntkomma’s veroorzaken vaak syntaxfouten. Rider en andere IDE’s geven direct een foutmelding als een statement niet correct is afgesloten. Onthoud: een puntkomma is verplicht na elke losse instructie, maar niet bij blokken met {}. Dit is een fundamentele regel in C# en andere talen zoals Java en JavaScript.

2.3 - OneDrive

Thu, 12 Jun 2025 12:53:26 GMT

We werken zoveel mogelijk in de cloud, dus gebruiken we OneDrive als centrale opslag voor projecten, bestanden en documentatie. Met je schoolmail heb je toegang tot OneDrive en synchroniseert de OneDrive-map op je pc automatisch met de cloud zodra je online bent—zo heb je overal én altijd de nieuwste versies bij de hand. Open in Windows Verkenner je OneDrive-map. Maak in OneDrive een nieuwe map Informatica → daarin Programmeren. Maak binnen Programmeren de mappen: Opdrachten Bestanden Documentatie Projecten Evaluatie Plaats C#-projecten in Opdrachten, downloads in Bestanden, naslag in Documentatie, grote (groeps)projecten in Projecten en opdrachtevaluaties in Evaluatie. Gebruik korte, beschrijvende map- en bestandsnamen: Opdracht1_Calculator.csproj, DataModel_Documentatie.pdf. Werk met duidelijke versietags in de naam (_v1.0, _v1.1) of vertrouw op OneDrive’s versiegeschiedenis om fouten te herstellen. OneDrive slaat automatisch eerdere versies van bestanden op en bewaart verwijderde items 30 dagen in de Prullenbak. Herstel een vorige versie via rechtermuisknop → Versiegeschiedenis of herstel een per ongeluk verwijderd bestand uit de Prullenbak. Deel mappen of bestanden met klasgenoten of je leerkracht via de knop Delen in Verkenner of de OneDrive-webapp. Stel rechten in (alleen weergeven of bewerken) en gebruik gedeelde mappen voor groepsopdrachten: iedereen werkt in dezelfde map en OneDrive synchroniseert real-time wijzigingen. Bespaar schijfruimte door in de OneDrive-instellingen alleen de mappen lokaal te synchroniseren die je actief nodig hebt (selective sync). Laat grote mappen of zelden gebruikte bestanden “online-only” staan; je ziet ze wel in Verkenner, maar ze nemen geen lokale ruimte in beslag. Met een heldere mappenstructuur, goede naamgeving en de deel- en versiemogelijkheden van OneDrive werk je veilig én efficiënt samen aan al je programmeeropdrachten.

2.1 - Benodigde software

Thu, 12 Jun 2025 12:47:49 GMT

Voordat we met Rider aan de slag kunnen gaan, moeten we eerst .NET downloaden via https://dotnet.microsoft.com/download. Op die pagina zie je twee downloadkeuzes: .NET SDK .NET Runtime Kies altijd de SDK, niet alleen de runtime!De .NET SDK (Software Development Kit) is het complete ontwikkelpakket waarmee je .NET-toepassingen maakt, bouwt en test. Ze bevat: .NET CLI (dotnet-commando’s) Project aanmaken (dotnet new mvc, dotnet new console) Bouwen (dotnet build) Uitvoeren (dotnet run) Pakketten beheren (dotnet add package ) Compilers Roslyn-C#-compiler en F#-compiler zetten jouw broncode om naar CIL (Common Intermediate Language). .NET Runtime & Libraries De Common Language Runtime (CLR) voor JIT-compilatie en garbage collection. Core-bibliotheken (collections, I/O, JSON-serialisatie, ASP.NET Core, Entity Framework Core, …). Projectsjablonen Voor web-API’s, MVC-sites, console-apps, Blazor, gRPC, en meer. Tooling Intellisense-plugins, analyzers en code-generators die Rider en Visual Studio sneller maken. Compiler nodig: zonder SDK kun je geen nieuwe projecten maken of je code compileren. Side-by-side installaties: je kunt meerdere SDK-versies naast elkaar hebben (bijv. 6.0, 7.0, 8.0) en per project de juiste versie kiezen. CLI workflows: met de dotnet-tools automatiseer je build-, test- en deploy-stappen; ideaal voor continu-integratie (CI/CD). Nu je de .NET SDK hebt, is Rider direct klaar om je C#-project te beheren, te bouwen en te debuggen. Veel programmeerplezier!