C# Classes & Objects: Fundamenten voor Robuuste OOP

In deze tutorial leert u over het concept van klassen en objecten in C# met behulp van voorbeelden.

C# is een objectgeoriënteerde taal die applicaties structureert rond objecten. In OOP lossen we complexe problemen op door ze op te breken in herbruikbare, zelfstandige objecten.

Om met objecten te werken, moeten we de volgende activiteiten uitvoeren:

• Een klasse aanmaken
• Objecten instantiëren vanuit die klasse

C# Klasse

Een klasse is het blauwdruk voor een object. Denk eraan als een huisplanning: het definieert kamers, deuren, ramen en structurele regels. Een echt huis gebouwd vanaf die planning is een object.

Meerdere huizen kunnen dezelfde planning delen, net als veel objecten gemaakt kunnen worden vanuit dezelfde klasse.

Een klasse aanmaken in C#

class ClassName { }

Hier hebben we een klasse gedefinieerd met de naam ClassName. Een klasse kan bevatten:

• Velden – variabelen die data bevatten
• Methodes – functies die acties uitvoeren

Voorbeeld:

class Dog {
    // Veld
    string breed;
    // Methode
    public void Bark() {
        // Implementatie
    }
}

In het bovenstaande voorbeeld:

• Dog – klassenaam
• breed – veld
• Bark() – methode

Let op: In C# omvatten leden van een klasse zowel velden als methodes.

C# Objecten

Een object is een instantie van een klasse. Bijvoorbeeld, de klasse Dog kan objecten produceren zoals een Buldog, Duitse Herder of Mops.

Een Object van een Klasse Aanmaken

ClassName obj = new ClassName();

Hier creëert new een object; obj is de naam. Bijvoorbeeld:

Dog bullDog = new Dog();

Het bullDog object kan nu de velden en methodes benaderen gedefinieerd in Dog.

Klasselidmaat Benaderen via een Object

Benader leden met de punt (.) operator:

using System;
namespace ClassObject {
    class Dog {
        string breed;
        public void Bark() {
            Console.WriteLine("Blaf Blaf !!");
        }
        static void Main(string[] args) {
            // Dog object aanmaken
            Dog bullDog = new Dog();
            // ras instellen
            bullDog.breed = "Bulldog";
            Console.WriteLine(bullDog.breed);
            // methode aanroepen
            bullDog.Bark();
            Console.ReadLine();
        }
    }
}

Output

Bulldog
Blaf Blaf !!

Let op het gebruik van bullDog en de puntoperator om breed en Bark() te benaderen.

Meerdere Objecten van een Klasse Aanmaken

Instantieer meerdere objecten uit dezelfde klasse, elk met eigen data:

using System;
namespace ClassObject {
    class Employee {
        string department;
        static void Main(string[] args) {
            // eerste werknemer
            Employee sheeran = new Employee();
            sheeran.department = "Development";
            Console.WriteLine("Sheeran: " + sheeran.department);
            // tweede werknemer
            Employee taylor = new Employee();
            taylor.department = "Content Writing";
            Console.WriteLine("Taylor: " + taylor.department);
            Console.ReadLine();
        }
    }
}

Output

Sheeran: Development
Taylor: Content Writing

Elk object houdt zijn eigen department waarde.

Objecten Aanmaken in een Andere Klasse

Objecten kunnen in andere klassen worden aangemaakt. Bijvoorbeeld:

using System;
namespace ClassObject {
    class Employee {
        public string name;
        public void Work(string work) {
            Console.WriteLine("Werk: " + work);
        }
    }
    class EmployeeDrive {
        static void Main(string[] args) {
            // Employee object aanmaken
            Employee e1 = new Employee();
            Console.WriteLine("Werknemer 1");
            // naam instellen
            e1.name = "Gloria";
            Console.WriteLine("Naam: " + e1.name);
            // methode aanroepen
            e1.Work("Coderen");
            Console.ReadLine();
        }
    }
}

Output

Werknemer 1
Naam: Gloria
Werk: Coderen

Hier creëert EmployeeDrive een Employee object. Publieke leden staan kruisklasse toegang toe. Meer over access modifiers in de officiële docs.

Waarom Objecten en Klassen?

Klassen en objecten maken modulaire ontwerp mogelijk. Voor een spel met veel vijanden kan een enkele Enemy klasse health, ammo, Shoot() en Run() definiëren. Elke vijand-instantie houdt dan zijn eigen state bij terwijl gedrag gedeeld wordt.

Door code te modelleren rond objecten, verminderen we complexiteit, verbeteren onderhoudbaarheid en bevorderen herbruikbaarheid.