[C# ?] Vraag over pseudocode uit een online cast.

[Uhmmie]

Na het zien van deze cast https://www.infoq.com/pre...8-lines-code-refactoring/ zou ik graag meer over dit onderwerp willen leren. Nu kon ik alles vrij goed volgen tot een van de laatste punten. Op een gegeven moment bestaat een zijn sheets uit het volgende:

code:

void  BootStrap()    {          
  handlers.Add(x  =>  Deactivate(()  =>  new  ItemRepository(),  x));          
  handlers.Add(x  =>  Reactivate(()  =>  new  ItemRepository(),  x));          
  handlers.Add(x  =>  CheckIn(()  =>  new  ItemRepository(), new BarService(), x));    
}  

public  static  void  Deactivate(
  ItemRepository  repository,
  DeactivateCommand  c)    {            
    var  item  =  repository.GetById(c.id);            
    item.Deactivate();    
} 

public  static  void  Reactivate(
  ItemRepository  repository,
  ReactivateCommand  c)    {            
    var  item  =  repository.GetById(c.id);            
    item.Reactivate();    
}

Ik gok dat de bovenstaande voorbeelden gebaseerd zijn op C#? (maar daar heb ik helaas nog geen ervaring mee).
Het verschil tussen de Deactivate() en Reactivate is dat ze een andere type X ontvangen.

In de bootstrap functie voegen ze aan de class handlers dus lamdba's toe die doormiddel van partial application al een deel van de parameters vullen en vervolgens dus alleen nog maar een X ontvangen.

Helaas gaat de cast verder niet in op hoe die Add functie dan geimplementeerd wordt en beter nodig hoe we vervolgens die lijst met lambda's kunnen toepassen? Hoe zou ik bijvoorbeeld dmv van die handlers class een ReactivateCommand kunnen uitvoeren?

Iemand die mij misschien de juiste zoektermen kan vertellen zodat ik meer over dit onderwerp kan vinden? Of kan uitleggen hoe je dit in de praktijk zou kunnen toepassen?

Ik heb al zitten zoeken op Delegates, Func en Action, maar dat is volgens mij toch net weer even iets anders dan wat er hierboven in het voorbeeld gebeurd.

[Haan]

Ik vind het een spuuglelijke constructie, even heel snel een paar fragmentjes van die cast bekeken, maar hij is dus op een of andere manier een soort van hard-coded dependencies aan het creëren. Waarom zou je in vredesnaam op deze manier dependencies aan methods - nota bene- mee willen geven?
Ik zou hier weg van blijven.

Dit zal inderdaad C# zijn, maar dat maakt niet zo heel veel uit verder.

[Uhmmie]

Haan schreef op vrijdag 15 januari 2021 @ 13:24:
Ik vind het een spuuglelijke constructie, even heel snel een paar fragmentjes van die cast bekeken, maar hij is dus op een of andere manier een soort van hard-coded dependencies aan het creëren. Waarom zou je in vredesnaam op deze manier dependencies aan methods - nota bene- mee willen geven?
Ik zou hier weg van blijven.

Dit zal inderdaad C# zijn, maar dat maakt niet zo heel veel uit verder.

Omdat ik het leuk vind om inzichten van andere te bekijken, zeker als ze afwijken van de mainstream. Soms leer ik er iets van, soms niet. Ik vind dit soort casts iig informatiever dan de zoveelste doe X met framework Y in taal Z. Als je aan het einde van zo'n cast beseft dat je je huidige manier van werken beter vind dan weet je dat ook weer voor de volgende keer.

Verder zit deze spreker achter EventStoreDB (https://www.eventstore.com/about), dus dat zal onder andere wel een oorzaak zijn aangezien zijn programmeren gebaseerd is op event sourcing en dat is toch ook wel een hele andere manier van denken en ontwikkelen.

[RedFox]

Ik kwam deze uitwerking tegen van iemand in java, misschien dat dat je iets verder helpt: https://gist.github.com/k...2dd4d6feb77131efd9ca1d76b

[Essie689]

RedFox schreef op zondag 17 januari 2021 @ 12:25:
Ik kwam deze uitwerking tegen van iemand in java, misschien dat dat je iets verder helpt: https://gist.github.com/k...2dd4d6feb77131efd9ca1d76b

Goede vondst. Ik was er wel al allerlei blogs over tegen gekomen, maar deze implementatie had ik nog niet gevonden. Bedankt voor het delen.

[SymbolicFrank]

Je kunt niet zomaar een method aanroepen. Die hebben een onzichtbare, eerste parameter: this. Het ziet er dus zo uit:

code:

Class.Method(ObjectInstance, Para1, Para2, ....);

En die ObjectInstance verwijst naar "this". Je moet dus eerst zo'n object kunnen maken en er een pointer naartoe hebben, wat lastig is als dat in de een of andere bibliotheek zit.

Verder zit je met het probleem, dat in een multithreaded applicatie, of als jouw functie moet wachten op iets anders, het goed kan zijn dat je object al is gewijzigd of niet meer bestaat. Bijvoorbeeld als de bibliotheek (framework/platform/dll, enz) die je gebruikt geschreven is in C++, heeft hij zijn eigen geheugenbeheer.

Wat hij eigenlijk bouwt is een message loop. Je hebt een gestandaardiseerd object, een message, dat je doorgeeft aan alle functies. Alle gegevens die je nodig hebt om de gevraagde functie uit te voeren moeten daar in zitten.

In de praktijk is een object natuurlijk gewoon een pointer naar een blokje data. Als je daar weer een pointer naar dat eerste object in stopt, heb je nog steeds dezelfde problemen. Je moet daarom een kopietje maken van alle gegevens en daarnaar verwijzen. En na het uitvoeren van de functie moet dat blokje data weer opgeruimd worden.

code:

bool MessageHandler(message Msg)
{
  If HandleMessage(Msg) == True 
  {
    Destroy(Msg);
    Return True;
  }
  Dispatch(Msg);
  Return False;
}

Ieder blok code / thread / class heeft dan zijn eigen message handler, die kijkt of hij de gevraagde functie kan uitvoeren. Zo niet, dan stuurt hij het berichtje naar de volgende ontvanger of terug naar het hoofdprogramma.

Dat is inderdaad de simpelste manier om deze problemen op te lossen. Maar de uitleg en uitvoering in de video zijn wel heel omslachtig en ingewikkeld.