DI Service Versionierung - Meinung/Vorschläge zur Implementierung

  • C#
  • .NET 5–6

Es gibt 2 Antworten in diesem Thema. Der letzte Beitrag () ist von slice.

    DI Service Versionierung - Meinung/Vorschläge zur Implementierung

    Ahoi zusammen,
    ich würde gerne mal eure Meinung zu folgendem Thema haben.

    Ich schreibe gerade eine Anwendung, die mit verschiedenen REST-APIs spricht.
    Problem ist, das einige der APIs mit Updates immer wieder Breaking-Changes mitbringen und da ich gerne mehrere Versionen pro API unterstützen möchte, ist nun die Frage wie ich das am besten Implementiere.

    Um das Problem zu visualisieren:

    Quellcode

    1. DataSourceA
    2. v1.0
    3. - GetUser()
    4. - GetGroup(...)
    5. - ...
    6. v2
    7. - GetUser(...)
    8. - GetGroup(...)
    9. - ...
    10. v3
    11. - GetCurrentUser()
    12. - GetGroup()

    Das ist jetzt nur eine sehr extreme und vereinfachte Darstellung der Situation, aber ich hoffe es verdeutlicht das Problem.
    Mit v2 erwartet die Methode GetUser Parameter und in v3 wurde die Methode zu GetCurrentUser umbenannt.

    Mir fallen derzeit zwei Varianten ein, wie ich das implementieren könnte, würde aber gerne eure Meinung dazu hören und eventuell hat einer eine bessere Idee?

    Implementation 1

    C#-Quellcode

    1. namespace Foobar.Services
    2. {
    3. internal class DataSourceAService
    4. {
    5. private readonly IDataSourceAVersion service;
    7. public DataSourceAService(string version)
    8. {
    9. switch (version)
    10. {
    11. case "v1":
    12. this.service = new DataSourceAV1();
    13. break;
    14. case "v2":
    15. this.service = new DataSourceAV2();
    16. break;
    17. default:
    18. throw new NotImplementedException();
    19. }
    20. }
    22. public void Exec()
    23. {
    24. this.service.Exec();
    25. }
    27. private interface IDataSourceAVersion
    28. {
    29. void Exec();
    30. }
    32. private class DataSourceAV1 :IDataSourceAVersion
    33. {
    34. public void Exec()
    35. {
    36. throw new NotImplementedException();
    37. }
    38. }
    40. private class DataSourceAV2 :IDataSourceAVersion
    41. {
    42. public void Exec()
    43. {
    44. throw new NotImplementedException();
    45. }
    46. }
    47. }
    48. }


    Implementation 2

    C#-Quellcode

    1. namespace Foobar.Services
    2. {
    3. interface IDataSourceBService
    4. {
    5. void Exec();
    6. }
    8. internal class DataSourceBServiceV1 :IDataSourceBService
    9. {
    10. public void Exec()
    11. {
    12. throw new NotImplementedException();
    13. }
    14. }
    16. internal class DataSourceBServiceV2 :IDataSourceBService
    17. {
    18. public void Exec()
    19. {
    20. throw new NotImplementedException();
    21. }
    22. }
    23. }


    PS: Ich tendiere zu Implementation 2, um dann mit dem Factory method pattern die richtige Version zu bekommen - dürfte fürs Testen auch einfacher sein.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „slice“ ()