Partial Classes in C#
Inleiding
Je kunt de broncode van een klassendefinitie in meerdere bestanden zetten en de broncode bestanden zijn in het geval van C# .cs-bestanden. Maar waarom zou je zoiets willen? Je zou zoiets willen als bijvoorbeeld meerdere developers zich bezig houden met een klasse en elke developer zijn eigen afgebakend stuk heeft. De klasse kan in zo’n geval voor iedere developer een partial klasse worden en de compiler zal uiteindelijk alle losse stukjes samenvoegen tot één groot gelukkig geheel.
Ook Visual Studio maakt gebruik van partial klassen. Zo kan je bijvoorbeeld via Visual Studio met Enitity Framework (EF) een klassendefinitie genereren uit een tabel in een (SQL Server) database. Je zult dan o.a. zien dat de properties van de gegenereerde klasse overeenkomen met de velden van de desbetreffende tabel.
De klassendefinitie kan je in Visual Studio op elk moment weer opnieuw genereren zodra je wijzigingen hebt aangebracht aan de desbetreffende tabel (bijvoorbeeld omdat je een veld hebt toegevoegd).
Je ziet dat Visual Studio met EF ook gebruik maakt van partial klassen en in dit geval is een apart stukje van de klasse specifiek bestemd voor datgene wat uit een database wordt gegenereerd (in dit voorbeeld een tabel met de naam tblLog). Het opnieuw genereren van de klasse uit de tabel geschiedt dan alleen hier en andere onderdelen van de klasse worden er niet direct mee lastig gevallen.
We zullen het één en ander weer illustreren aan de hand van fictieve autofabrikant “GHB GuanggongHunnenburgBetrieb”, een fabrikant dat geboren is uit een nieuw internationaal samenwerkingsverband.
Class Library
De autofabrikanten Hunnenburg Gesellschaft mit beschränkter Haftung en Guanggong Automotive Industry hebben besloten hun krachten te bundelen. Zo heeft Hunnenburg heel veel ervaring met verbrandingsmotoren. Hunnenburg was één van de pioniers op het gebied van verbrandingsmotoren en haar ervaring gaat terug tot het begin van de 20e eeuw. Guanggong is ook een partij van formaat. Zo is zij één van de marktleiders op de oriëntale automarkt en ze heeft een hele goede reputatie op het gebied van wielophanging en veersystemen.
De teams van beide fabrikanten slaan hun handen ineen voor de nieuwste GHB auto waarbij het overkoepelende hoofdkantoor de properties van de klasse formuleert, Hunnenburg zich zal toeleggen op de motor en Guanggong de wielophanging en de veersystemen zal doen.
Een Class Library wordt gemaakt met een partial klasse waarbij we een aantal class bestanden toevoegen waardoor de structuur van de Class Library Solution / Project er in Visual Studio als volgt uitziet:
En we zien dat er nu aparte .cs-broncodebestanden zijn. De teams kunnen nu los van elkaar aan hun eigen .cs-bestanden werken. Het zijn allemaal partial classes waarna de compiler alles zal samenvoegen tot het grote gelukkige geheel.
Partial Class I.
In GHB.cs staan o.a. de properties van de (partial) GHB klasse. Dit deel van de klasse wordt gedaan door het IT bedrijfsbureau op het overkoepelende hoofdkantoor waarbij dit onderdeel van de klasse weer een basis is voor de specialisten bij Hunnenburg en Guanggong:
using System;
namespace GHBConglomeraat
{
public enum Kleur
{
Groen,
Paars,
Geel,
Oranje,
Rood,
Grijs
}
public partial class GHB
{
// Backing variables - fields
private string _merk;
private int _milieusticker;
private string _vervuilingsgraad;
// Property Merk
public string Merk
{
get { return _merk; }
set { _merk = value; }
}
// Property MilieuSticker
public int MilieuSticker
{
get { return _milieusticker; }
set { _milieusticker = value; }
}
// Property Vervuilingsgraad
public string Vervuilingsgraad
{
get { return _vervuilingsgraad; }
}
// Constructor - als 2 parameters zijn opgegeven
public GHB(string merk, int milieusticker)
{
_milieusticker = milieusticker;
_merk = merk;
_vervuilingsgraad = OverJeAuto(milieusticker);
}
// Constructor - Als 1 parameter is opgegeven
public GHB(string merk)
: this(merk,
(int)Kleur.Groen) { }
// Constructor - Als geen parameters zijn opgegeven
public GHB()
: this("GHB (
GuanggongHunnenburgBetrieb)",
(int)Kleur.Groen) { }
// Methode OverJeAuto(int kleur)
public string OverJeAuto(int kleur)
{
return "Voldoet aan alle millieunormen";
}
}
}
Partial Class II.
Voor het team dat zich bezighoudt met de motor is er .cs-bestand Hunnenburg.cs:
using System;
namespace GHBConglomeraat
{
public partial class GHB
{
// Methode Motor
public string Motor()
{
return "Unseren hochmodernen
Hunnenburg motoren
ermöglicht eine exakte
Überwachung der
Abgasrückführung.";
}
}
}
Partial Class III.
En voor het team dat zich bezighoudt met de vering is er .cs-bestand Guanggong.cs:
using System;
namespace GHBConglomeraat
{
public partial class GHB
{
// Methode Vering
public string Vering()
{
return "Guanggong suspension
complies with the highest
automotive industry standards.";
}
}
}
Object
De Class Library compileren we naar één .dll assembly waarbij alle onderdelen van partial class GHB worden samengevoegd tot één klasse. In de console applicatie leggen we een link naar de .dll en we maken gebruik van de GHB-klasse waaruit we een object instantiëren:
using System;
using GHBConglomeraat;
namespace GedeeltelijkeKlasse
{
class MainClass
{
public static void Main(string[] args)
{
// instantieer
GHB mijnGBH = new GHB();
// En we hebben..
Console.WriteLine(
"Je bent in het trotse bezit van:");
Console.WriteLine(
"een {0}.\r\n", mijnGBH.Merk);
Console.WriteLine(
"De Milieusticker van je bolide is {0}.\r\n",
(Kleur)mijnGBH.MilieuSticker);
Console.WriteLine(
"M.b.t. de vervuilingsgraad van je auto:\r\n" +
"{0}\r\n", mijnGBH.Vervuilingsgraad);
Console.WriteLine(
"Over de motor:\r\n{0}\r\n",mijnGBH.Motor());
Console.WriteLine(
"Over de vering:\r\n{0}\r\n", mijnGBH.Vering());
}
}
}
Resultaat
En we zien dat de methoden in de afzonderlijke .cs-bestanden in het Class Library-project gevonden worden en kunnen worden aangeroepen:
Je bent in het trotse bezit van:
een GHB (GuanggongHunnenburgBetrieb).
De Milieusticker van je bolide is Groen.
M.b.t. de vervuilingsgraad van je auto:
Voldoet aan alle millieunormen
Over de motor:
Unseren hochmodernen Hunnenburg
motoren ermöglicht eine exakte
Überwachung der Abgasrückführung.
Over de vering:
Guanggong suspension complies
with the highest automotive
industry standards.
Press any key to continue...
Slot
In deze post heb ik laten zien hoe je de definitie van een klasse kunt opsplitsen naar drie aparte broncode (.cs) bestanden. Het opsplitsen is met name handig in situaties waarin meerdere developers zich bezig houden met een klasse en elke developer zijn eigen afgebakend stuk heeft. De developers kunnen dan aan hun eigen stukje werken zonder elkaar in de weg te zitten. De compiler zal uiteindelijk alles tot één geheel samenvoegen.
Partial classes worden ook door Visual Studio met Entity Framework gebruikt om klassendefinities te genereren uit tabellen in een database. Op die manier kan de klassendefinitie na elke wijziging in de database opnieuw gegenereerd worden zonder andere delen van de klasse in de weg te gaan zitten.
We hebben het één en ander geïllustreerd met het voorbeeld van fictieve autofabrikant “GHB GuanggongHunnenburgBetrieb” waarin de teams hun eigen broncode bestanden hebben. De teams kunnen zo werken aan de delen van de auto waaraan ze zijn toegewezen. Het zijn allemaal gescheiden bestanden waardoor ze elkaar niet in de weg gaan zitten en wordt voorkomen dat wijzigingen verloren gaan doordat het ene team de bestanden van een ander team overschrijft.
Software laten bouwen door verschillende developers / teams? Partial classes zijn een mooie aanzet, maar je zal op een gegeven moment toch bij het “echte” broncode versiebeheer werk komen en daar zijn weer allerlei gespecialiseerde tools voor (Azure DevOps Server (of hoe het tegenwoordig ook mag heten), Github, GitLab, BitBucket etc. etc.).
Hopelijk ben je met deze posting weer wat wijzer geworden en ik hoop je weer terug te zien in één van mijn volgende blog posts. Wil je weten wat ik nog meer over C# heb geschreven? Hit the C# button…