[C#/.NET]OOP/Structuur vraag

[Razr]

Mede-devvers,

Voor een applicatie waarin ik dynamisch aan de hand van een aangeleverde (soort van .csv) file een scherm moet opbouwen, wil ik een aantal standaard klassen uitbreiden met wat eigenschappen.

Een voorbeeld van zo'n eigenschap is bijv. een integer welke elke control uniek moet maken. De controls die ik nodig heb zijn o.a. de Button, TextBox en de ComboBox.

Wat ik nu in mijn hoofd heb is een superklasse te maken welke alle properties en methods bevat welke ik straks nodig heb voor alle controls die ik dynamisch ga toevoegen. Vervolgens wil ik dus bijv. een button laten erven van deze superklasse.
Maar het probleem is dat ik alleen kan ervan van óf mijn superklasse óf van de System.Windows.Forms.Button klasse (waarvan ik het gedrag voor de button nodig heb). Ik kan wel voor elke control een bovenliggende klasse schrijven maar dan heb je nog vrij veel duplicatie kwa code. En dat is niet echt OOP lijkt mij.

Een ander idee wat ik had is om een interface te maken en daarin de methoden en de eigenschappen vast te leggen. Vervolgens een klasse laten erven van bijv. System.Windows.Forms.Button en de interface koppelen. Hierdoor moet ik nog wel overal het gedrag beschrijven maar dan is er wel een 'is-een' relatie. Alleen blijkbaar kan ik geen eigenschappen definiëren in een interface, en sowieso lijkt deze oplossing me niets.

Ik heb nog gezocht op een evt. mogelijkheid van het overriden van een klasse. Ik dacht om de System.Windows.Forms.Control klasse te overriden en hier mijn properties aan toe te voegen.

Wat is de netste/beste optie om voor elkaar te krijgen wat ik wil?

Hopenlijk is het een beetje duidelijk

[bigbeng]

Het klinkt alsof je Multiple Inheritance wil. Even kijken of ik je verhaal begrijp: In feite wil jij een Control class maken met alle methodes die gelden voor al jouw customer controls. Vervolgens wil je implementaties maken van kinderen van de control klasse, die ook van hun Windows.Form.<Controlclass> overerven. Klopt dit?
Zo ja, dan heb ik helaas slecht nieuws voor je. Dit is niet mogelijk in C#.

Er zijn wel mensen geweest die gepoogd hebben om in de buurt te komen van een soort van MI, maar voor zover ik heb gezien is niemand er in geslaagd om in de buurt te komen.

[Razr]

bigbeng schreef op maandag 07 juli 2008 @ 15:04:
Het klinkt alsof je Multiple Inheritance wil. Even kijken of ik je verhaal begrijp: In feite wil jij een Control class maken met alle methodes die gelden voor al jouw customer controls. Vervolgens wil je implementaties maken van kinderen van de control klasse, die ook van hun Windows.Form.<Controlclass> overerven. Klopt dit?
Zo ja, dan heb ik helaas slecht nieuws voor je. Dit is niet mogelijk in C#.

Er zijn wel mensen geweest die gepoogd hebben om in de buurt te komen van een soort van MI, maar voor zover ik heb gezien is niemand er in geslaagd om in de buurt te komen.

Je begrijpt mijn verhaal inderdaad goed. Ik ben via het internet zelf ook wel eens op het 'Multiple Inheritance' gestuit en inderdaad gelezen dat dat niet mogelijk zou zijn. Maar nooit gedacht dat dit een beperking zou zijn waar ik zelf te maken mee zou krijgen.

Is er dan misschien een andere manier om deze situatie op te lossen? Mijn leer boek houdt nog steeds stug vol dat iemand anders mijn problemen ook al een keer heeft gehad (én opgelost)

Op dit moment gebruik ik een soort wrapper. Ik heb een klasse over laten erven van System.Windows.Form.Control. Deze bevat een aantal eigenschappen waarvan één een public Control is. D.m.v. een foreach loop kan ik nu door een Control collectie heenlopen en de nodige controls toevoegen d.m.v. de public Control propertie. Plus dat ik de eigen gedefineerde eigenschappen/methods kan gebruiken.

Desalniettemin zie ik dit niet als een oplossing maar meer als een (hopenlijk tijdelijke ) work-around. Ik loop namelijk wel tegen beperkingen aan. Graag zou ik een goede (design pattern achtige) oplossing horen voor deze situatie.

[ Voor 27% gewijzigd door Razr op 07-07-2008 15:21 ]

[bigbeng]

Je zou eens kunnen kijken naar het Decorator pattern: http://en.wikipedia.org/wiki/Decorator_pattern

[Niek.NET]

Misschien zou je het kunnen oplossen met Generics:

C#:

public class Ding<T> : where T : System.Windows.Control
{

private T _control = null;

   public Ding<T>(T ding)
   {
       _control = ding;
   }

   public T ControlDinges
   {
      get{ return _control; }
   }
}

Niet getest/gebuild maar het zou je een idee moeten geven van hoe dit te implementeren

[Laurens-R]

Lijk me zowieso al dat deze topic SE&A moet komen te staan. Maar goed...

Ik stel voor dat je toch je architectuur omhoop moet gooien en idd: generics is een goed punt.

[ Voor 11% gewijzigd door Laurens-R op 07-07-2008 15:24 ]

[Verwijderd]

Ik denk dat je sowieso een fundamentele fout maakt dat je eigenschappen wilt toevoegen aan classes voor de user interface. Natuurlijk zijn die user controls niet onbelangrijk in code waar je je scherm dynamisch opbouwt, maar je wilt niet eigenschappen van de user interface (properties van een Button bijvoorbeeld) gaan mixen met eigenschappen voor je functionaliteit (unieke codes). Dat moet je gewoon scheiden in classes en niet één grote verzamelclass maken. Dus wat je dan krijgt is een aparte class waarin je die eigenschappen definieert. Je kunt eventueel voor de eigenschappen voor een button nog een derived class maken.

Je hebt dan een aantal mogelijkheden om deze class aan je user control te hangen. De ASP.NET controls hebben geen Tag property, dus zul je wat anders moeten verzinnen. Een optie is een dictionary waarbij je de class met eigenschappen aan je user controls hangt. Een andere optie is je een derived class van Button maken, met een interface. In deze interface staat dat er een property aanwezig van het type class met je eigenschappen. Zonder interface kan ook; dan heb je in die derived class gewoon een property naar je class met eigenschappen.


Edit:

Niek.NET schreef op maandag 07 juli 2008 @ 15:20:
Misschien zou je het kunnen oplossen met Generics:

[...]

Niet getest/gebuild maar het zou je een idee moeten geven van hoe dit te implementeren

En dan wordt er op een knop gedrukt, en hoe kom je dan bij je Ding class? Een aparte class met eigenschappen is dus een goed idee, maar de verwijzing moet twee kanten op zijn.

[ Voor 20% gewijzigd door Verwijderd op 07-07-2008 15:37 . Reden: reactie op Niek.NET ]

[Niek.NET]

Verwijderd schreef op maandag 07 juli 2008 @ 15:33:
<knip>

Helemaal mee eens, ik zei ook niet dat dit de beste oplossing was maar ik gaf alleen een manier om zijn huidige ontwerp te implementeren. Dit soort 'moeilijke' design problemen zijn inderdaad een goede indicatie dat er iets mis is op architectonisch niveau.

[Woy]

De vraag is natuurlijk ook wat je precies wilt. Als je alleen functionaliteit/stateless methoden toe wilt voegen kun je bijvoorbeeld ook iets met extension methods of een static helper class doen.