[G_PRO] Basis Programmeren en OO Programmeren
DigitAP
  • Welkom
  • Inleiding
    • Benodigdheden
    • Afspraken code
    • Afspraken oefeningen
    • Nuttige extras
    • Dankwoord
    • Mee helpen?
  • Semester 1: Programming Principles
    • H1: Werken met Visual Studio
      • Introductie tot C#
      • Visual Studio en .NET Core installeren
      • Een C# project maken in Visual Studio
      • Fouten in je code
      • Je eerste stappen in C#
      • Input/Output: ReadLine/WriteLine
      • Kleuren in Console
      • Oefeningen
    • H2: Variabelen en datatypes
      • De syntaxis van C#
      • Datatypes
      • Variabelen
      • Expressies en operators
      • Oefeningen
    • H3: Strings en hun methoden
      • Strings
      • Strings samenvoegen
      • Omzetten van en naar strings
      • Functionaliteit van strings
      • Oefeningen
    • H4: Beslissingen
      • Beslissingen intro
      • Enkelvoudige booleaanse expressies
      • If, else, else if
      • Samengestelde booleaanse expressies
      • Scope van variabelen
      • Switch
      • Oefeningen
    • H5: Loops
      • Loops intro
      • While en Do While
      • For
      • Debuggen
      • Oefeningen
    • H6: Arrays
      • Array principes
      • Alternatieve syntax
      • Werken met arrays
      • Defaultwaarden
      • List<T>
      • Oefeningen
    • H7: Methoden
      • Methoden intro
      • Parameters
      • Return waarden
      • Geavanceerde methoden
      • Oefeningen
    • Intermezzo: TextCell
    • H8: Numerieke data
      • De Math klasse
      • Random
      • Casting en conversie
      • Oefeningen
    • H9: Meerdimensionaal werken
      • N-dimensionale arrays
      • Geneste iteratie
      • Oefeningen
    • H10: Gevorderde tekstverwerking
      • Voorstelling van tekst
      • Interpolatie met formattering
      • Werken met arrays van strings
      • Input en output van tekstbestanden
      • Oefeningen
    • Afsluiter: TextCell2D
  • Semester 2 : OOP
    • H10: Klassen en objecten
      • OOP Intro
      • Klassen en objecten aanmaken
      • DateTime: leren werken met objecten
      • Enumeraties: nog een eigen datatype
      • Klassen en objecten weergeven deel 1
      • Attributen
      • Methoden
      • Access modifiers
      • Properties
      • Oefeningen
    • H11: Objecten (al dan niet) aanmaken
      • Constructors
      • Spelen met strings
      • Oefeningen
    • H12: Geheugenmanagement bij klassen
      • value en reference met eigen objecten
      • nullable value types
      • NullReference exception
      • Oefeningen
    • H13: Datastructuren
      • Foreach en var
      • List
      • Dictionary
      • Immutable datastructuren
      • Verdere datastructuren
      • Oefeningen
    • H14: Overerving
      • Overerving intro
      • Virtual en override
      • Abstract
      • Constructors bij overerving
      • Oefeningen
    • H15: Geavanceerde overerving
      • protected access modifier
      • Base keyword
      • System.Object
      • Oefeningen
    • H16: Exception handling
      • Werken met exceptions
      • Zelf uitzonderingen maken
      • Wanneer exceptions en handling gebruiken
      • Oefeningen
    • H17: Polymorfisme en interfaces
      • Polymorfisme
      • Polymorfisme in de praktijk
      • Interfaces
      • Losse koppeling
      • Oefeningen
    • H18: Testing
      • Intro Testing
      • Wat is Unit Testing
      • Waarom Unit Testing?
      • Wanneer Unit Testing?
      • Schrijven van een unit test: AAA methode
      • Eerste voorbeeld: Sum
      • Assert
      • Oefening even of oneven getal
      • TestInitialize en DataRows
      • Oefening BMI
      • Exception testing
      • Oefening BMI exception
      • Oefening SchoolAdmin test null-waarden en TestCleanup
      • Oefening SchoolAdmin test equals
      • Oefening SchoolAdmin test cursus zoeken met id
      • Dependencies bij Unit Testing
      • Mocking
      • Oefeningen Mocking
      • Test Driven Development
      • Class Library
      • Oefeningen TDD
    • H19: SOLID
      • Single Responsibility Principle (SRP)
      • Open/Closed Principle (OCP)
      • Liskov Substitution Principle (LSP)
      • Interface Segregation Principle (ISP)
      • Dependency Inversion Principle (DIP)
  • Appendix
    • Visual Studio Tips & Tricks
    • Ea-ict coding guidelines
    • Oefeningen kerkhof
  • Semester 1 appendix
    • Nice to know stuff
      • Out en Ref parameters
      • Jagged arrays
    • All-In-Projecten
      • Overzicht
      • Console Matrix
      • Ascii filmpjes maken met loops
      • Ascii filmpjes maken met methoden
      • Fun with methods: een verhaalgenerator
      • Tekst-gebaseerd Maze game
      • Conway game of life
  • Semester 2 appendix
    • Operator overloading
    • Object Initializer Syntax
    • Compositie en aggregatie
    • Nice to know stuff
      • Klassen herbruiken
      • Expression bodied members
    • All-In-Projecten
      • Overzicht
      • OO Textbased Game
      • War Simulator
      • Map Maker
      • Magic The Gathering API
      • SchoolAdmin
  • Pro (geen leerstof en/of in opbouw)
    • Bitwise operators
    • Generics en collections
      • Generics methoden en types
      • Generic classes en constraints
      • Collections
      • Labo-oefeningen
    • Events
      • Events
      • Chat server
    • Software engineering
      • SOLID
Powered by GitBook
On this page
Export as PDF
  1. Semester 2 : OOP
  2. H19: SOLID

Open/Closed Principle (OCP)

Het Open/Closed Principle (OCP) stelt dat klassen open moeten staan voor uitbreiding, maar gesloten moeten blijven voor wijzigingen. Met andere woorden, je zou nieuwe functionaliteit moeten kunnen toevoegen aan een systeem zonder de bestaande code van dat systeem te wijzigen. Dit bevordert het behoud van de stabiliteit van bestaande code terwijl je nieuwe functies introduceert.

In C# kan het OCP worden toegepast door gebruik te maken van abstractie, interfaces en het gebruik van polymorfisme (het vermogen van objecten om zich anders te gedragen op basis van hun specifieke implementaties).

Laten we dit principe illustreren aan de hand van een eenvoudig voorbeeld. Stel je voor dat je een applicatie hebt die verschillende soorten vormen moet kunnen tekenen, zoals cirkels en rechthoeken. Laten we eerst een niet-OCP-compatibele implementatie bekijken en vervolgens een OCP-compatibele benadering.

Niet-OCP-compatibele implementatie:

public class Circle
{
	public double Radius { get; set; }
		
	public void DrawCircle()
	{
    		// Code om een cirkel te tekenen
	}
}

public class Rectangle
{
	public double Width { get; set; }
	public double Height { get; set; }

	public void DrawRectangle()
	{
    		// Code om een rechthoek te tekenen
	}
}

Als je een nieuwe vorm wilt toevoegen, moet je de bestaande code aanpassen en nieuwe methoden toevoegen om de nieuwe vorm te tekenen. Het grootste probleem is dat je niet kan itereren over aan collectie van deze objecten en tegen elk object kan zeggen dat het zichzelf moet tekenen.

OCP-compatibele implementatie:

public interface IShape
{
	void Draw();
}

public class Circle : IShape
{
	public double Radius { get; set; }

	public void Draw()
	{
    		// Code om een cirkel te tekenen
	}
}

public class Rectangle : IShape
{
	public double Width { get; set; }
	public double Height { get; set; }

	public void Draw()
	{
   		// Code om een rechthoek te tekenen
	}
}

Met deze implementatie introduceren we een interface genaamd IShape die een gemeenschappelijke Draw-methode heeft. Nu kunnen we nieuwe vormen toevoegen door eenvoudig nieuwe klassen te maken die IShape implementeren en de Draw-methode invullen. Hierdoor kunnen we nieuwe functionaliteit toevoegen zonder bestaande code te wijzigen.

Als we nu een collectie van IShape objecten hebben kunnen we hier over itereren en tegen elk object zeggen dat het zichzelf moet tekenen. Op deze manier kunnen we dus in de toekomst oneindig veel figuren toevoegen, zo lang deze maar IShape implementeren. Onze code zal dan steeds correct blijven werken.

Het Open/Closed Principle moedigt dus aan om bestaande code niet te wijzigen wanneer nieuwe functies worden toegevoegd, maar eerder uitbreidingen te maken via abstractie en interfaces. Dit zorgt voor een meer flexibele en onderhoudbare codebase.

PreviousSingle Responsibility Principle (SRP)NextLiskov Substitution Principle (LSP)

Last updated 1 year ago