[c#] automatiseringsfunctie

[Ontspannen]

Hallo allemaal,

Ik heb een programma dat tekst doet bewerken.

Nu wil ik het mogelijk maken dat de gebruiker een automatiseringsfunctie kan uitvoeren.
Dus de gebruiker kan vooraf instellen welke functies er achter elkaar uitgevoerd worden.
Dus dit wordt dan een list van opdrachten.
Aangezien je vast meerdere wil aanmaken wordt dat dan een list van list van opdrachten.

Deze gedachte had ik al eerder en heb toen delegates geprobeerd, het ging wel maar
wanneer je functies met verschillende parameters hebt dan wordt het geheel toch
complexer.( tenzij hier een oplossing voor is)

Mij lijkt de eenvoudigste oplossing om voor iedere soort bewerking een klasse aan te maken
en een interface met de methode uitvoeren(). Zo kan er voor voor iedere tekst bewerking
een instantie aangemaakt worre en dan polymorphisme via interface zoals men dat
schijnt te noemen.

Ik zie eigenlijk op tegen het type werk, het zijn veel functies.

Wat vinden jullie?

Tnks

[Marco1994]

Ik zou het gewoon in klassen knallen, namelijk iets in de zin van functie 1----* opdracht. Dan kun je nog met overerving verschillende opdrachten defineren

[ChaZy]

Ik heb verder weinig kaas gegeten van deze techonologie, maar is WorkFlow misschien iets voor je?

https://www.google.nl/web...&ie=UTF-8#q=c%23+workflow

[DieVeenman]

http://stackoverflow.com/...all-a-function-in-c-sharp

Eventueel dit als basis gebruiken en dan verder uitbreiden zodat mensen ook een "volgorde" kunnen selecteren

[Ontspannen]

'k ga de reflection uit proberen omdat deze beter lijkt aan te sluiten op het programma
wat ik nu heb.

Dus ik ga me nu concentreren op het maken van een list van invokes en hoe ik de gegevens
ga opslaan die bij iedere invoke hoort. Immers de invoke's worden aangemaakt met bij behorende
gegevens om ze vervolgens op een later tijdstip achter elkaar uit te voeren.

En ook bedankt voor het wijzen op workflow ga daar zeker nog een keer naar kijken.

Thnks voor het meedenken

[Daos]

Reflection lijkt mij in deze niet handig.

voor iedere soort bewerking een klasse aan [...] maken

Lijkt mij de mooiste oplossing. Je moet dan wel een soort programmeertaal ontwerpen en een parser schrijven die een tekstbestand/invoerveld in jouw taal omzet naar een boom van je eigen klassen.

Ik zou beginnen met de vraag: hoe wil je dat een gebruiker je systeem opdrachten geeft? (lees: hoe ziet mijn eigen programmeertaal eruit?) Alles is mogelijk.

[RobIII]

Ipv het wiel opnieuw uitvinden: zoek eens naar het command pattern (of memento pattern). Ik zit even mobiel dus linkjes enzo zijn lastig maar zal ik desgewenst nog plaatsen.

Dit levert vast ook zinnige(re) resultaten: [google=.net undo pattern]

[ Voor 17% gewijzigd door RobIII op 12-04-2016 20:17 ]

[Ontspannen]

Ik zou beginnen met de vraag: hoe wil je dat een gebruiker je systeem opdrachten geeft?

Die opdrachten staan al in de interface dus dan zie ik twee mogelijkheden:
a: ik laat de gebruiker in die zelfde interface op een knop drukken en er verschijnen 'één keuze
rondjes' achter de opdrachten en dan middels algoritme steeds een opdracht laten kiezen. etc..

b: ik maak een nieuw formulier aan waarin ik het opdrachten deel van de interface overneem
en dan weer het zelfde concept als bij a.

Het idee met de klasse is eigenlijk de eenvoudigste maar wel het meeste werk. Zo'n opdrachten
'boom' bestaat uit instanties van klassen die de zelfde opdracht uitvoeren maar wel met een andere
uitvoering (polymorfisme). Gegevens die de bewerking nodig heeft kunnen in zo'n instantie opgeslagen worden. Als het goed is kan die opdrachten lijst met een xml parser (serialisatie) naar een bestand
geschreven worden.

Maar..... dat met die reflection is nieuw voor me dus ik wil daar eerst eens me spelen misschien
bevalt het. 'k heb gelukkig een beeld van wat ik wil anders kan je maar beter de lange route kiezen.

thnks voor je input

[Ankona]

Ik kan niet echt goed achterhalen wat je precies wil en tegen welke uitdagingen je aanloopt. Bij het lezen moest ik meteen denken aan function delegates, zoals je zelf ook wel aangaf.
Maar bij het verder lezen denk ik toch meer aan een oplossing middels een strategy pattern om de functies (gedrag) te injecteren en een composite pattern om het gedrag samen te stellen uit meerdere functies.

[ThunderNet]

Eventueel kun je hier ook de workflow foundation voor inzetten

[Ontspannen]

Ankona schreef op woensdag 13 april 2016 @ 21:03:
composite pattern om het gedrag samen te stellen uit meerdere functies.

Het eenvoudigst, maar het meeste werk, is voor iedere functie een klasse met een interface.
Je maakt een instantie van de klasse aan met de benodigde gegevens en zet deze in een
(object) array. De gebruiker wil op een bepaalt moment z'n 'script' uitvoeren. Betekend: de
array aflopen, iedere instantie casten naar het type van de interface en vervolgens
de methode van de interface uitvoeren. Dynamische binding doet de rest.

Ankona schreef op woensdag 13 april 2016 @ 21:03:
een strategy pattern om de functies (gedrag) te injecteren.

Kan zijn dat ik dit verkeerd begrijp.
Wanneer een object array is aangemaakt dan kan deze ook 'eenvoudig' opgeslagen en geladen worden.


thnks