ServiceCollection Extension mit Dependency als Parameter?

  • C#
  • .NET 5–6

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

    ServiceCollection Extension mit Dependency als Parameter?

    Hey,
    ich prügel mich gerade mal wieder mit Thema Dependency Injection bzw. der Extension-Method um den Service zu registrieren.
    Aktuelle Implementierung

    C#-Quellcode

    1. internal static IServiceCollection AddGraphClient(this IServiceCollection services, IConfiguration proxyConfig, IConfiguration credentialConfig)
    2. {
    3. services.Configure<GraphAuthProxySettings>(proxyConfig);
    4. services.Configure<GraphAuthCredentialSettings>(credentialConfig);
    5. services.AddSingleton<IGraphAuthService, GraphAuthService>();
    6. services.AddSingleton<IIdentityLogger, GraphAuthIdentityLogger>();
    7. services.AddSingleton<IMsalHttpClientFactory, GraphAuthHttpClientFactory>();
    8. services.AddTransient<DelegatingHandler, GraphAuthTokenHandler>();
    9. services.AddSingleton(sp =>
    10. {
    11. var handlers = GraphClientFactory.CreateDefaultHandlers();
    12. handlers.Add(sp.GetRequiredService<GraphAuthTokenHandler>());
    13. handlers.Add(sp.GetRequiredService<HttpLoggingHandler>()); // um die Zeile geht es
    14. var httpClient = GraphClientFactory.Create(handlers);
    16. return new GraphServiceClient(httpClient);
    17. });
    19. return services;
    20. }

    Konkret geht es um folgende Zeile: handlers.Add(sp.GetRequiredService<HttpLoggingHandler>());

    Der Teil ist aktuell hardcoded, jedoch ist HttpLoggingHandler nicht Bestandteil der Library und soll veränderbar sein.
    Ich stehe gerade total auf dem Schlauch und krieg es nicht hin, das als Parameter zu realisieren.

    Was ich gefunden habe, wäre folgendes:
    Spoiler anzeigen

    C#-Quellcode

    1. internal static IServiceCollection AddGraphClient<TService>(this IServiceCollection services, IConfiguration proxyConfig, IConfiguration credentialConfig, Func<IServiceProvider, TService> factory) where TService : DelegatingHandler
    2. {
    3. TService finalHandler = factory(services.BuildServiceProvider());
    5. // ...
    6. services.AddSingleton(sp =>
    7. {
    8. var handlers = GraphClientFactory.CreateDefaultHandlers();
    9. handlers.Add(sp.GetRequiredService<GraphAuthTokenHandler>());
    10. handlers.Add(finalHandler);
    11. var httpClient = GraphClientFactory.Create(handlers);
    13. return new GraphServiceClient(httpClient);
    14. });
    16. return services;
    17. }

    Aber services.BuildServiceProvider() aufzurufen ist keine gute Idee und bringt Probleme mit der Service LifeTime etc.

    Den DelegatingHandler direkt als Parameter zu übergeben ist auch problematisch, da er so von Hand erstellt werden muss und wir wieder beim Thema "Service LifeTime" wären.

    Irgendwer eine schlaue Idee?

    Doppelpost incoming :whistling:

    Ok, auf Stackoverflow wurde ich auf meine Blindheit hingewiesen ...
    Für einen DelegatingHandler ist das einfach
    Spoiler anzeigen

    C#-Quellcode

    1. internal static IServiceCollection AddGraphClient<TService>(this IServiceCollection services,
    2. IConfiguration proxyConfig,
    3. IConfiguration credentialConfig) where TService : DelegatingHandler {
    5. // ...omitted for brevity
    7. services.AddSingleton(sp => {
    8. var handlers = GraphClientFactory.CreateDefaultHandlers();
    9. // ...
    10. handlers.Add(sp.GetRequiredService<TService>()); //<--resolve TService and add to handlers
    11. var httpClient = GraphClientFactory.Create(handlers);
    12. return new GraphServiceClient(httpClient);
    13. });
    14. return services;
    15. }


    Danach habe ich mich nochmal einige Stunden mit dem Thema beschäftigt.
    Wie könnte ich das lösen, wenn ich eine Liste von DelegatingHandler hinzufügen wollte und bin zu folgender Implementierung gekommen:
    Spoiler anzeigen

    C#-Quellcode

    1. internal class GraphHandlers
    2. {
    3. private List<Type> handlers;
    4. public IReadOnlyCollection<Type> Handlers { get { return this.handlers.AsReadOnly(); } }
    6. public GraphHandlers()
    7. {
    8. this.handlers = new List<Type>();
    9. }
    11. public GraphHandlers Add<THandler>() where THandler : DelegatingHandler
    12. {
    13. this.handlers.Add(typeof(THandler));
    14. return this;
    15. }
    16. }


    C#-Quellcode

    1. internal static IServiceCollection AddGraphClient(this IServiceCollection services,
    2. IConfiguration proxyConfig,
    3. IConfiguration credentialConfig,
    4. GraphHandlers graphHandlers)
    5. {
    6. foreach (var handler in graphHandlers.Handlers)
    7. {
    8. services.AddTransient(handler);
    9. }
    11. // ..
    12. services.AddSingleton(sp =>
    13. {
    14. var handlers = GraphClientFactory.CreateDefaultHandlers();
    15. // ..
    16. foreach (var handler in graphHandlers.Handlers)
    17. {
    18. handlers.Add((DelegatingHandler)sp.GetRequiredService(handler));
    19. }
    21. var httpClient = GraphClientFactory.Create(handlers);
    22. return new GraphServiceClient(httpClient);
    23. });
    25. return services;
    26. }


    C#-Quellcode

    1. builder.Services.AddGraphClient(
    2. builder.Configuration.GetSection("Proxy"),
    3. builder.Configuration.GetSection("GraphCredentials"),
    4. new GraphHandlers().Add<WhatEverHandler>().Add<HttpLoggingHandler>()
    5. );

    Es funktioniert, nur ist die Frage ob das eine solide Implementierung ist?
    Irgendwelche Anmerkungen dazu?

    slice schrieb:

    Irgendwelche Anmerkungen dazu?
    Du gibst eine IServiceCollection hinein und returnst eine IServiceCollection - und zwar genau diejenige, die du hineingegeben hast.
    Wenn du nicht etwas besonderes damit bezweckst, sollte die Methode lieber void sein.

    Ansonsten alles höchst verschwurbelt: services bekommt die Handlers aus GraphHandlers.Handlers geadded.
    Und einen Singleton, der iwas mit GraphClientFactory.CreateDefaultHandlers() macht - da scheinbar noch iwelche anderen Handlers zufügt, die wiederum aus sp.GetRequiredService(handler)) gebildet wrden. Mit diese Handlers wird ein httpClient erzeugt, und von dem ein neuer GraphServidClient - das wird returnt - äh - von einer anonymen Methode, die den services zugefügt wird.

    Also wenn du da selbst durchblickst, ist das schoma sehr gut. Und wenns funktioniert umso besser. Ob das eine solide Implementierung ist - dazu müsste man mehr davon verstehen. Ausgesprochen unsolides ist mir nicht aufgefallen - ich würd mir nur etwas einfacheres wünschen, aber weiss natürlich nicht, ob das möglich ist.

    Das mit dem IServiceCollection als Rückgabewert ist einfach so ein Ding von Dependency-Injection damit man die aneinanderhängen kann.

    Das das alles etwas verschwurbelt ist, da geben ich dir recht, ist aber leider auch Microsoft und/oder meiner Unwissenheit wie man es besser lösen kann geschuldet?
    Um das etwas aufzubröseln:
    Ich brauch ein GraphServiceClient mit eigenen DelegatingHandler
    1. Generiere Default-Handler (Redirect, Compression etc) mittels GraphClientFactory.CreateDefaultHandlers()
    2. Füge eigene Handler hinzu handlers.Add((DelegatingHandler)sp.GetRequiredService(handler));
    3. Erstelle vorkonfigurierten HttpClient (mit deren Feature-Flags etc) für GraphServiceClient
    4. Registriere den Service - in meinem Fall als Singleton, da es keinen Sinn macht jedes mal eine neue Instanz zu erstellen


    Als zusätzliche Info, hier die Doku von Microsoft um einen benutzerdefinierten Client zu erstellen:
    Spoiler anzeigen

    C#-Quellcode

    1. // tokenCredential is one of the credential classes from Azure.Identity
    2. // scopes is an array of permission scope strings
    3. var authProvider = new AzureIdentityAuthenticationProvider(tokenCredential, scopes: scopes);
    5. var handlers = GraphClientFactory.CreateDefaultHandlers();
    7. // Remove a default handler
    8. // Microsoft.Kiota.Http.HttpClientLibrary.Middleware.CompressionHandler
    9. var compressionHandler =
    10. handlers.Where(h => h is CompressionHandler).FirstOrDefault();
    11. handlers.Remove(compressionHandler);
    13. // Add a new one
    14. // ChaosHandler simulates random server failures
    15. // Microsoft.Kiota.Http.HttpClientLibrary.Middleware.ChaosHandler
    16. handlers.Add(new ChaosHandler());
    18. var httpClient = GraphClientFactory.Create(handlers);
    19. var customGraphClient = new GraphServiceClient(httpClient, authProvider);


    Nachtrag bezüglich deinem "ich würd mir nur etwas einfacheres wünschen":
    Das ist genau der Grund, warum ich eine Extension-Method dafür schreiben möchte, da ich das so oft brauche und keine Lust habe es jedes Mal von neuem zu schreiben.

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

    Wenn du die Handler via DI registrieren möchtest, könnte es vielleicht so klappen? Ich kenne die Libs nicht, die du nutzt, aber wenn ich den Code richtig lese, sollten die Handler alle von DelegatingHandler erben, oder?

    C#-Quellcode

    1. services.AddSingleton(sp =>
    2. {
    3. var registeredHandlers = sp.GetRequiredServices<IEnumerable<DelegatingHandler>>();
    4. var defaultHandlers = GraphClientFactory.CreateDefaultHandlers();
    6. foreach (var registeredHandler in registeredHandlers)
    7. {
    8. defaultHandlers.Add(registeredHandler);
    9. }
    11. var httpClient = GraphClientFactory.Create(handlers);
    12. return new GraphServiceClient(httpClient);
    13. });
    15. // Handler dann so registrieren:
    16. services.AddSingleton<DelegatingHandler, HandlerA>();
    17. services.AddSingleton<DelegatingHandler, HandlerB>();
    18. services.AddSingleton<DelegatingHandler, HandlerC>();


    Hier musst du aufpassen, dass die Handler auch immer als Singleton registriert werden. Die Types beim Registrieren müssen auch passen (also DelegatingHandler muss in den Typeparams sein). Dafür könntest du auch easy ne Extension AddGraphHandler<THandler>(THandler handler) schreiben, die den Add Call macht.

    Alternativ könntest du überlegen, die Handler überhaupt nicht vom DI Container kommen zu lassen. Das wäre leichter, geht aber nur, wenn die Handler selbst keine DI Deps haben. Da du sowieso schon eine eigene Extension AddGraphClient hast, könntest du die Handler dort einfach dynamisch als Parameter akzeptieren. Beispielsweise so, per Factory Funktion:

    C#-Quellcode

    1. internal static IServiceCollection AddGraphClient(
    2. this IServiceCollection services,
    3. /* ...andere Parameter... */,
    4. Func<IEnumerable<DelegatingHandler>> customHandlerFactory)
    5. {
    6. services.AddSingleton(sp =>
    7. {
    8. var customHandlers = customHandlerFactory();
    9. var defaultHandlers = GraphClientFactory.CreateDefaultHandlers();
    11. foreach (var customHandler in customHandlers)
    12. {
    13. defaultHandlers.Add(customHandler);
    14. }
    16. var httpClient = GraphClientFactory.Create(handlers);
    17. return new GraphServiceClient(httpClient);
    18. });
    20. return services;
    21. }
    23. // Aufruf dann so:
    24. services.AddGraphClient(
    25. // ...andere Parameter...
    26. customHandlerFactory: () => new DelegatingHandler[] { new HandlerA(), new HandlerB(), new HandlerC() });

    shad schrieb:

    ...sollten die Handler alle von DelegatingHandler erben, oder?

    Korrekt, aber alle registrieren DelegatingHandler hinzufügen ist kein gute Idee, da auch andere registriert sein könnten, die nichts mit Graph am Hut haben.

    shad schrieb:

    Hier musst du aufpassen, dass die Handler auch immer als Singleton registriert werden. Die Types beim Registrieren müssen auch passen

    DelegatingHandler sind da etwas merkwürdig mit ihrer Service Lifetime, hier ein Link der das relativ gut erklärt: DI scopes in IHttpClientFactory message handlers don't work like you think they do
    Wobei das in meinem Fall nicht sonderlich relevant sein sollte, da die Handler stateless sind.

    shad schrieb:

    Alternativ könntest du überlegen, die Handler überhaupt nicht vom DI Container kommen zu lassen. Das wäre leichter, geht aber nur, wenn die Handler selbst keine DI Deps haben.

    Das ist leider ein Problem, einige Handler haben Abhängigkeiten :(

    Hmm, das ist dann echt ein spezielleres Problem. Auf die Schnelle gedacht, würde sowas reichen? Ist eine leicht abgewandelte Version von meinem vorherigen zweiten Fragment, mit dem Unterschied, dass die Factory jetzt Services vom ServiceProvider holen kann. Damit könnte der Aufrufer der AddGraphClient Extension spezifische Services auswählen, die gleichzeitig vom DI Container kommen:

    C#-Quellcode

    1. internal static IServiceCollection AddGraphClient(
    2. this IServiceCollection services,
    3. /* ...andere Parameter... */,
    4. Func<IServiceProvider, IEnumerable<DelegatingHandler>> customHandlerFactory)
    5. {
    6. services.AddSingleton(sp =>
    7. {
    8. var customHandlers = customHandlerFactory(sp);
    9. var defaultHandlers = GraphClientFactory.CreateDefaultHandlers();
    10. foreach (var customHandler in customHandlers)
    11. {
    12. defaultHandlers.Add(customHandler);
    13. }
    15. var httpClient = GraphClientFactory.Create(handlers);
    16. return new GraphServiceClient(httpClient);
    17. });
    18. return services;
    19. }
    21. // Aufruf dann so:
    22. services.AddGraphClient(
    23. // ...andere Parameter...
    24. customHandlerFactory: (sp) =>
    25. new DelegatingHandler[]
    26. {
    27. sp.GetRequiredService<HandlerA>(),
    28. sp.GetRequiredService<HandlerB>(),
    29. sp.GetRequiredService<HandlerC>(),
    30. new HandlerD(),
    31. });

    Arg, wo warst du bitte vor ca. vier Wochen?
    Die Variante hätte natürlich den Charme, das ich mir die zusätzliche Klasse spare.

    Danke schön!

Facebook
Telefonspende