Een klasse in het object georiënteerd programmeren de basis voor eender welke entiteit.

Voorbeelden:

• Een WPF Window
• Een MessageBox
• Een TextBox
• Een Exception
• Een Console
• ...

In het dagelijkse leven zou je ook kunnen zeggen dat de klasse Auto een sjabloon is voor alle reële auto's, en voor elke auto vastlegt dat deze kan accelereren, remmen, wat de topsnelheid is, of er ABS aanwezig is, ...

• Wanneer je een WPF Window aanmaakt hoef je je geen zorgen te maken hoe die Window getoond wordt, hoe de knopjes minimaliseren, maximaliseren en sluiten aangemaakt worden.
• Wanneer je de methode WriteLine van de klasse Console uitvoert hoef je je niet af te vragen hoe deze zin in de Console wordt getoond
• Wanneer je de methode Versnel van je eigen klasse Auto uitvoert hoef je je niet steeds af te vragen wat de implementatie van die methode is (met de implementatie wordt de concrete invulling of dus de statements binnen de methode bedoeld).

• Voeg een nieuw item Circle.cs toe aan WpfKlassen van het type 'Class'

  Je krijgt volgende code te zien:

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace WpfKlassen
  {
  	class Circle
  	{
  	}
  }
  

  Hier maken we een nieuwe klasse met de naam Circle aan, het definiëren van een klasse wordt gekenmerkt door het sleutelwoord class.

  Visual Studio maakt een klasse aan met dezelfde naam als de .cs-file. Dit is geen verplichting. Het is zelfs mogelijk om meerdere klassen binnen een .cs-file te herbergen.

  In WPF is het perfect mogelijk cirkels te tekenen met de bestaande klassenstructuur, maar om eductieve doeleinden is het aan te raden om de theorie rond klassen te bekijken aan de hand van gekende, eenvoudige voorbeelden.
  Vandaar dat we in dit hoofdstuk een eigen klasse Circle maken, iedereen kan zich gemakkelijk voorstellen wat een cirkel is.

  Stel je voor dat we de oppervlakte (area) van een cirkel willen berekenen met behulp van de klasse cirkel.
  Om de oppervlakte van een cirkel te berekenen hebben we de straal (radius) van de cirkel nodig en het getal pi (vinden we -natuurlijk afgerond- door gebruik te maken van de klasse Math: Math.PI).

• Voeg een klassevariabele (field) radius toe: de straal wordt een variabele binnen onze klasse cirkel, de straal is bij ons een geheel getal.

  class Circle
  {
  	int radius;
  
  }
  

• Voeg een methode Area toe: deze methode retouneert een double-waarde.

  class Circle
  {
  	int radius;
  
  	double Area()
  	{
  		return Math.PI * radius * radius;
  	}
  }
  

Een klasse kan dus fields (variabelen) als methoden bevatten.
Zowel variabelen als methoden kwamen al aan bod tijdens een vorig hoofdstuk.

Een klasse vormt een sjabloon, een blauwdruk voor objecten of instanties.
De klasse Circle kunnen we nu dus gebruiken om Circle-objecten of Circle-instanties aan te maken.

Voorzie een Window_Loaded eventhandler in Window1:

private void Window_Loaded(object sender, RoutedEventArgs e)
{
	Circle c; //Circle-variabele declareren
	c = new Circle(); //Circle-variabele initialiseren
	
}

Probleem:

• we kunnen de straal niet instellen: c.radius blijkt niet te bestaan!
• de methode Area blijkt ook niet aan te roepen!

Fields en methods binnen een klasse zijn standaard gedeclareerd als private: ze kunnen enkel gebruikt worden binnen de klasse zelf.

• Pas radius en Area aan zodat ze public zijn:

  class Circle
  {
  	public int radius;
  
  	public double Area()
  	{
  		return Math.PI * radius * radius;
  	}
  }
  
  

  Vanuit Window1 kunnen we de public members van Circle benaderen:

  private void Window_Loaded(object sender, RoutedEventArgs e)
  {
  	Circle c;
  	c = new Circle();
  	c.radius = 5;
  	double opp = c.Area();
  	MessageBox.Show(opp.ToString());
  }
  

  

default constructor

Met een constructor in een klasse is het mogelijk velden van een nieuw object onmiddellijk te initialiseren.
Wanneer je zelf geen constructor voorziet in je klasse, dan genereert de compiler een standaardconstructor voor je klasse: elk veld van de klasse moet nu eenmaal geïnintialiseerd worden.

class Circle
{
	public int radius;

	public Circle() //standaard parameterloze constructor
	{
		radius = 0;
	}

	public double Area()
	{
		return Math.PI * radius * radius;
	}
}

public int radius;

public Circle() //standaard parameterloze constructor
{
	radius = 0;
}

public Circle(int beginRadius) //constructor waarbij we meteen de radius initialiseren
{
	radius = beginRadius;
}

public double Area()
{
	return Math.PI * radius * radius;
}

Circle c;
c = new Circle(5);

double opp = c.Area();
MessageBox.Show(opp.ToString());

public Circle(int radius) //constructor waarbij we meteen de radius initialiseren
{
	this.radius = radius;
}

Een klasse kan veel methoden, velden, constructors en andere items bevatten.
Een nuttige klasse kan op die manier behoorlijk omvangrijk worden.
Met C# kan je de broncode voor een klasse uitsplitsen in meerdere beheersbare stukken code, en zelfs over meerdere fysieke bestanden.
Dit principe wordt eigenlijk gebruikt in elke WPF-toepassing of ASP.Net Website die je maakt en heet partial classes.

• In je WPF toepassing zie je volgende code in Window1.xaml.cs:

  public partial class Window1 : Window
  

• In Window1.xaml lezen we:

  <Window x:Class="WpfKlassen.Window1" ...
  

  Eigenlijk vormt de code die je voorziet in Window1.xaml.cs samen met de code die we vinden in Window1.xaml de klasse Window1.
  De twee files vormen dus bij compilatie één klasse!

  Vandaar dat wijzigingen die je in de ene file uitvoert onmiddellijk hun weerslag hebben in de andere: een control die je op het Window voorziet is direct bruikbaar in de codebehind-file.

  • Doe volgende wijziging aan de klasse Circle:

    partial class Circle
    ...
    

  • Voeg een nieuwe class-file Circle2.cs toe:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace WpfKlassen
    {
    	partial class Circle
    	{
    		public double Circumference()
    		{
    			return 2 * radius * Math.PI;
    		}
    	}
    }
    

  • In het WPF-window merk je niet dat de klasse Circle is opgesplitst in twee partial classes:

    Circle c;
    c = new Circle(5);
    
    double opp = c.Area();
    double circ = c.Circumference();
    MessageBox.Show(
                     String.Format
                     (	
                       "Opp.: \t{0}\nOmtrek:\t{1}"
                       ,opp.ToString()
                       ,circ.ToString()
                     )
                    );
    
    

    Een leuk nieuwigheidje dat hier ook wordt geïntroduceerd is het gebruik van de String.Format methode.
    Op deze manier kan je een tekenreeks voorzien van plaatshouders (int waarden tussen accoloades), en de variabele stukken als parameters meegeven.

    Toepassing: Point

    Maak een klasse Point bestaande uit twee parial klasses in twee files (Point.cs en Point2.cs).

    Een Point wordt in onze toepassing gedefiniëerd in een vlak en heeft dus een x- en een y-coördinaat, beide zijn int waarden.

    Voorzie een constructor waarmee we een Point kunnen initialiseren en onmiddellijk x en y kunnen aangeven.

    Voorzie een methode DistanceTo voor een Point. Deze methode van de Point-klasse ontvangt een Point-variabele en berekent de afstand tussen deze twee punten als double.
    Voor deze berekening is wat wiskunde nodig uit het secundair onderwijs, wellicht is Pythagoras geen volstrekt onbekende voor jou.

    Constructors en fields komen in Point.cs, methoden maak je in Point2.cs.

    Maak een WPF-toepassing waarmee de gebruiker de input kan voorzien en de afstand kan berekenen:

    

    Toon /verberg

     
    Point.cs
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace WpfKlassen
    {
    	partial class Point
    	{
    		public int x;
    		public int y;
    
    		public Point(int x, int y)
    		{
    			this.x = x;
    			this.y = y;
    		}
    	}
    }
    
    
    
    
    
    Point2.cs
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace WpfKlassen
    {
    	partial class Point
    	{
    		public double DistanceTo(Point p)
    		{
    			int xdiff = Math.Abs(x - p.x);
    			int ydiff = Math.Abs(y - p.y);
    
    			double diff = Math.Sqrt(Math.Pow(xdiff, 2) + Math.Pow(ydiff, 2));
    			return diff;
    			
    		}
    	}
    }
    
    
    Window1.xaml.cs
    
    private void btnBereken_Click(object sender, RoutedEventArgs e)
    {
    	Point p1 = new Point(Convert.ToInt32(txtP1x.Text),Convert.ToInt32(txtP1y.Text));
    	Point p2 = new Point(Convert.ToInt32(txtP2x.Text),Convert.ToInt32(txtP2y.Text));
    	double afstand = p1.DistanceTo(p2);
    	lblAfstand.Content = afstand.ToString();
    }
    
    

Static method

Wanneer je hier wat dieper bij nadenkt, dan merk je dat dit in ons voorbeeld met de klasse Point zou neerkomen op de code Point.DistanceTo om de afstand tussen punten te berekenen.
Dit lukt echter niet, DistanceTo is bij ons een instantiemethode: we hebben een instantie van de klasse Point nodig:

Point p = new Point(5,6)
p.DistanceTo(...

Zoals de voorbeelden met de klasse Math aantonen is het ook mogelijk om methoden, maar ook fields te declareren die je rechtstreeks met de naam van de klasse kan aanroepen. Dergelijke methoden of fields noemen we static.

• Voeg een static methode DistanceTo toe aan de klasse Point:

  Point2.cs
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace WpfKlassen
  {
  	partial class Point
  	{
  		public double DistanceTo(Point p)
  		{
  			int xdiff = Math.Abs(x - p.x);
  			int ydiff = Math.Abs(y - p.y);
  
  			double diff = Math.Sqrt(Math.Pow(xdiff, 2) + Math.Pow(ydiff, 2));
  			return diff;
  			
  		}
  
  	  public static double DistanceTo(Point p1, Point p2)
  	  {
  		  return p1.DistanceTo(p2);
  	  }
  	}
  }
  

  De methode berekent de afstand tussen twee punten, nu is het wel nodig om twee Point-objecten mee te geven, daar je de methode niet toepast op een van de instanties.

  Nu kan je in Window1 de afstand tussen twee punten als volgt berekenen:

  Point p1 = new Point(Convert.ToInt32(txtP1x.Text),Convert.ToInt32(txtP1y.Text));
  Point p2 = new Point(Convert.ToInt32(txtP2x.Text),Convert.ToInt32(txtP2y.Text));
  
  double afstand = Point.DistanceTo(p1, p2);
  lblAfstand.Content = afstand.ToString();
  
  

Static field

Niet alleen methods kunnen static zijn, ook field die dus data bevatten kunnen static zijn.

Dit heeft grondige gevolgen: de data die een static field bevat is dezelfde voor elke instantie van de klasse.

• Op deze maier kunnen we een field declareren dat bijhoudt hoeveel instanties van een Point er reeds werden gemaakt:

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace WpfKlassen
  {
  	partial class Point
  	{
  		public int x;
  		public int y;
  		public static int objectCount; 
  
  		public Point()
  		{
  			objectCount++;
  		}
  		public Point(int x, int y):this()
  		{
  			this.x = x;
  			this.y = y;
  		}
  	}
  }
  

  Een static field van het type int met de naam objectCount werd gedeclareerd.
  In de parameterloze constructor zorgen we ervoor dat objectCount met 1 wordt opgehoogd als een Point wordt geïnstantieerd.
  We willen natuurlijk dat dit ook gebeurt wanneer we de andere constructor gebruiken. Nu zou je de opdracht objectCount++ hier kunnen hernemen, beter is echter de constructors aan elkaar te ketenen (constructor-chaining).

  Dit doen we door vanuit een constructor een andere constructor aan te roepen met behulp van :this()-syntax.

• In Window1 kan je dit aantal tonen:

  private void btnBereken_Click(object sender, RoutedEventArgs e)
  {
  	Point p1 = new Point(Convert.ToInt32(txtP1x.Text),Convert.ToInt32(txtP1y.Text));
  	ToonAantalPoints();
  	Point p2 = new Point(Convert.ToInt32(txtP2x.Text),Convert.ToInt32(txtP2y.Text));
  	ToonAantalPoints();
  	Point p3 = new Point();
  	ToonAantalPoints();
  
  	double afstand = Point.DistanceTo(p1, p2);
  	lblAfstand.Content = afstand.ToString();
  }
  
  private void ToonAantalPoints()
  {
  	MessageBox.Show("Aantal Point-objecten: " +Point.objectCount.ToString());
  }
  

• Je zou de ketting natuurlijk omgekeerd kunnen maken:

  partial class Point
  {
  	public int x;
  	public int y;
  	public static int objectCount; 
  
  	public Point():this(0,0)
  	{
  		
  	}
  	public Point(int x, int y)
  	{
  		this.x = x;
  		this.y = y;
  		objectCount++;
  	}
  }
  
  

var anoniempje = new { Naam = "William", Leeftijd = 35 };
MessageBox.Show(
	String.Format(
		"anoniempje heet {0} en is van het type {1}"
		,anoniempje.Naam
		,anoniempje.GetType().Name
	)
		);

Hier wordt een anonieme klasse gemaakt met twee eigenschappen Naam en Leeftijd.
In de MessageBox zie je de door de compiler toegekende klassennaam.

Een eerte manier om een klasse te hergebruiken kan zijn om de cs-files heel eenvoudig te kopiëren naar een ander project, eventueel het namespace-argument aan te passen en klaar is Kees.
Wanneer je nu iets verder denkt zie je meteen in dat dit niet 'the way to go' is: wat als we een aanpassing willen doen aan een klasse? Gaan we nu alle projecten openen waarin we die klasse hebben gekopiëerd en doen we zoveel keer die aanpassing? Al vlug zal je in een situatie verzeild raken waar je verschillende versies van dezelfde klasse hebt.

Een veel doordachter en onderhoudsvriendelijker aanpak is het herbergen van je klassen in een Class Library: een klassenbibliotheek.

• Voeg aan de solution Klassen een nieuw project "Class Library" Ivo.Hbo.Geometry toe:

  

• Met de Solution Explorer knip je Circle.cs, Circle2.cs, Point.cs en Point2.cs weg uit WpfKlasse en plak je deze in je Class Library:

  

• Verwijder Class1.cs uit de Class Library
• Verander in de 4 files de namespace van WpfKlassen in Ivo.Hbo.Geometry
• Bij het builden van de solution krijg je nu foutmeldingen:

  

• Builden van de Class Library alleen lukt je wel (rechtklik de Class Library en kies build)

  

  Een Class Library wordt gecompileerd in een .dll-file.

• Om vanuit WPfKlassen met de klassen uit Ivo.Hbo.Geometry te kunnen werken moeten we een referentie naar deze dll leggen:
  Rechtsklik WpfKlassen en kies Add Reference...

  

  Maakt het project met de Class Library waarnaar je een referentie wenst te leggen deel uit van de huidige solution, dan is het tabblad projects die eenvoudigste manier. Je kan ook het tabblad browse gebruiken om de benodigde dll te selecteren.

• Na builden van de solution heb je nog steeds foutmeldingen.
  Doordat de klassen Circle en Point zich niet meer in de namespace WpfKlassen bevinden moeten we nu de volledige klassenaam vermelden, inclusief namespace:

  Ivo.Hbo.Geometry.Point en Ivo.Hbo.Geometry.Circle in plaats van Point en Circle, we doen dit niet.

  Je ziet onmiddellijk in dat dit voor een grotere toepassing een titanenwerk is, daarom kan je door middel van een using-statement voorzien dat de naam van de klasse voldoende is.

  ...
  using Ivo.Hbo.Geometry;
  
  namespace WpfKlassen
  {
  	/// <summary>
  	/// Interaction logic for Window1.xaml
  	/// </summary>
  	public partial class Window1 : Window
  	{
  

• Builden lukt nog steeds niet: vanuit een andere applicatie hebben we geen toegang tot de klassen Circle en Point, we zorgen er op klasseniveau voor dat ze public zijn, doe dit in de 4 files Circle.cs, Circle2.cs, Point.cs en Point2.cs

  public partial class Point
  

• Nu blijkt nog een conflict te bestaan:

  

  Blijkbaar bestaat er reeds een klasse met de naam Point in de namespace System.Windows.

  We lossen dit op door het using statement in Window1.xaml.cs aan te passen:

  using IHG = Ivo.Hbo.Geometry;
  

  IHG is hier een verkorte schrijfwijze die we kunnen gebruiken voor Ivo.Hbo.Geometry

• Zorg er nu voor dat in Window1.xaml.cs Circle wordt vervangen door IHG.Circle en Point door IHG.Point

  Je kan dit snel doen door 'zoeken en vervangen' (CTRL + H), opgepast dat je geen verkeerde vervangingen doet, best werken met Replace en Find Next (huidige overslaan) in plaats van 'Replace all'.

• Voor alle duidelijkheid nog eens de code voor de methode btnBereken_click:

  private void btnBereken_Click(object sender, RoutedEventArgs e)
  {
  	IHG.Point p1 = new IHG.Point(Convert.ToInt32(txtP1x.Text),Convert.ToInt32(txtP1y.Text));
  	ToonAantalPoints();
  	IHG.Point p2 = new IHG.Point(Convert.ToInt32(txtP2x.Text),Convert.ToInt32(txtP2y.Text));
  	ToonAantalPoints();
  	IHG.Point p3 = new IHG.Point();
  	ToonAantalPoints();
  
  	double afstand = IHG.Point.DistanceTo(p1, p2);
  	lblAfstand.Content = afstand.ToString();
  }
  

  Je merkt dat je dergelijke acties beter niet te vaak moet uitvoeren, het is beter de gewoonte aan te nemen om een verzameling bij elkaar horende klassen meteen in een Class Library te steken.