Generika unter einen Hut bringen

  • C#
  • .NET (FX) 3.0–3.5

Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von timmi31061.

    Generika unter einen Hut bringen

    Moin,

    ich habe zur Zeit das Problem, dass ich verschiedene Typen eines generischen Delegaten in einem Dictionary speichern möchte, um später durch Suchen nach einem Key den dazugehörigen Callback zu finden. Folgendes habe ich mir dazu vorgestellt.

    C#-Quellcode

    1. public class CommandManager
    2. {
    3. public delegate void CommandCallback<T>(T command) where T : ICommand;
    5. private Dictionary<Type, CommandCallback> callbacks;
    7. public CommandManager()
    8. {
    9. callbacks = new Dictionary<Type, CommandCallback>();
    10. }
    12. public void RegisterCommandHandler<T>(CommandCallback<T> callback) where T : ICommand
    13. {
    14. callbacks.Add(typeof(T), callback);
    15. }
    16. }

    Nun ist natürlich klar, dass das so nicht funktionieren kann. Die Frage ist nun, ob und, wenn ja, wie man so etwas realisieren kann. Vermutlich ist meine Herangehensweise falsch.
    Mit freundlichen Grüßen,
    Thunderbolt

    Du kannst hier entweder mit Reflection arbeiten, also im Dictionary objects speichern und dann über Reflection die Delegaten ausführen. Oder du kannst das in Klassen kapseln, die das für dich casten und nach außen hin keinen Typparameter haben.
    Wie das genau umzusetzen wäre, hängt davon ab, was du mit diesem Dictionary anstellen möchtest. Zeig mal bitte, wie du darauf zugreifen möchtest.

    Das wäre dann wohl eine solche Methode:

    C#-Quellcode

    1. public void ExecuteCommand<T>(T command) where T : ICommand
    2. {
    3. callbacks[typeof(T)](command);
    4. }

    Eventuell wären Informationen zum Verwendungszweck nicht schlecht. Es geht darum, binär serialisierte Klassen, die von ICommand erben, via TCP zu übertragen und die entsprechenden Handler damit zu füttern.
    Mit freundlichen Grüßen,
    Thunderbolt

    Wenn das der einzige Ort ist, an dem das Dictionary verwendet wird, kannst du wirklich einfach casten. Problematisch wird es erst, wenn du drauf zugreifen willst, wenn kein Typparameter angegeben ist.
    Mit diesen Änderungen sollte es schon funktionieren:

    C#-Quellcode

    1. ​ public class CommandManager
    2. {
    3. public delegate void CommandCallback<T>(T command) where T : ICommand;
    5. private Dictionary<Type, object> callbacks;
    7. public CommandManager()
    8. {
    9. callbacks = new Dictionary<Type, object>();
    10. }
    12. public void RegisterCommandHandler<T>(CommandCallback<T> callback) where T : ICommand
    13. {
    14. callbacks.Add(typeof(T), callback);
    15. }
    17. public void ExecuteCommand<T>(T command) where T : ICommand
    18. {
    19. ((CommandCallback<T>)callbacks[typeof(T)]).Invoke(command);
    20. }
    21. }

    Okay, dann mache ich das so. Ich habe anfangs zwar auch über eine solche Lösung nachgedacht, sie aber dann verworfen, da mir das Rumkonvertieren unsauber erschien. Wenn das die einzige bzw. simpelste Lösung ist, sollte das aber kein Problem darstellen. Vielen Dank!
    Mit freundlichen Grüßen,
    Thunderbolt

Facebook
Telefonspende