Handler

.AddHandler(object handlerSource) adds a handler as IHandlerBase.

IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandler(new Halver());

It can also add an IEnumerable<IHandlerBase>.

IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandlers(ServiceHandlers.Instance);

And as a ITuple.

IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandlers((ServiceHandlers.Instance.ServiceRequestHandler, new Halver()));

.AddHandler<T>() adds a handler by Type.

IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandler<Halver>();

.AddHandlers<T>() adds a IEnumerable<IHandlerBase>.

IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandlers<ServiceHandlers>();

Delegate Handlers

.AddHandler(Action<IQuery<Request, Response>>) adds a delegate as a handler.

// Create sum calculator
Action<IQuery<(int, int), int>> sumCalculator = q => q.Response.SetValue(q.Request.Item1 + q.Request.Item2);
// Service collection
IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandlers(ServiceHandlers.Instance)
    .AddHandler(sumCalculator);
// Services
using var services = serviceCollection.BuildAvalancheServiceProvider();
// Get avalanche service
IService service = services.GetRequiredService<IService>();
// Issue request to sumHandler
int sum = service.GetRequired<(int, int), int>((5, 6));

Delegate Action<IQuery> handles every type of query. Second argument 'long? order' defines evaluation order.

// Create query logger
static void queryLogger(IQuery q) => WriteLine(Services.MessageDescription.GoodQueryCompleted.Template.Print(null, new object?[] { q.Request, q.Response.Value(), q.Response.Status }));
// Service collection
IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandlers(ServiceHandlers.Instance)
    .AddHandler(queryLogger, order: long.MaxValue)

Async delegates are added as Func<IQuery<Request, Response>, Task>.

// Create async handler
static async Task urlDownloader(IQuery<string, string> q)
{
    HttpResponseMessage msg = await new HttpClient().GetAsync(q.Request);
    String content = await msg.Content.ReadAsStringAsync();
    q.Response.SetValue(content);
}
// Avalanche.Service
IServiceCollection serviceCollection =
    new ServiceCollection()
    .AddHandlers(ServiceHandlers.Instance)
    .AddHandler((Func<IQuery<string, string>, Task>)urlDownloader);
// Services
using var services = serviceCollection.BuildAvalancheServiceProvider();
// Get avalanche service
IService service = services.GetRequiredService<IService>();
// Get content
string? content = await service.GetAsync<string, string>("http://avalanche.fi");
// Print
Console.WriteLine(content);

And as Func<IQuery, Task> for async delegate.

// Create query logger async
static async Task queryLogger(IQuery q) => await Out.WriteLineAsync(Services.MessageDescription.GoodQueryCompleted.Template.Print(null, new object?[] { q.Request, q.Response.Value(), q.Response.Status }));
// Service collection
IServiceCollection serviceCollection = new ServiceCollection()
    .AddHandlers(ServiceHandlers.Instance)
    .AddHandler(queryLogger, order: long.MaxValue)

Handler gets an access to dependency injection

Handler gets an access to dependency injection with query.Service which implements IServiceProvider.

public class MyClassAccessor : IHandler<string, Type>
{
    public void Handle(IQuery<string, Type> query)
    {
        // Use dependency injection
        MyClass myClass = query.Service.GetRequiredService<MyClass>()!;
        // ...
    }
}

ServiceDescriptors

ServiceDescriptor can be converted to a IHandlerBase.

// Create service descriptor
ServiceDescriptor serviceDescriptor = ServiceDescriptor.Singleton<MyClass, MyClass>();
// 
IHandlerBase serviceDescriptorHandler = ServiceDescriptorExtensions.ToHandler(serviceDescriptor);

IEnumerable<ServiceDescriptor> is converted to IHandlerBases. Descriptors are coalesced and grouped by ServiceType.

// Create service descriptors
IServiceCollection serviceCollection = new ServiceCollection()
    .AddSingleton<MyClass>();
// 
IEnumerable<IHandlerBase> serviceDescriptorHandlers = ServiceDescriptorExtensions.ToHandlers(serviceCollection);

Full Example

Full example

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Avalanche.Service;
using Microsoft.Extensions.DependencyInjection;
using static System.Console;

class di_handler
{
    public static async Task Run()
    {

        {
            // Service collection
            // <01>
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandler(new Halver());
            // </01>
            // Avalanche.Service
            serviceCollection
                .AddHandlers(ServiceHandlers.Instance.ServiceRequestHandler)
                .AddCachePolicy(CachePolicies.Default)
                .AddEntryPolicy(EntryPolicies.Default)
                .AddAvalancheService();
            // Services
            using var services = serviceCollection.BuildServiceProvider();
            // Get avalanche service
            IService service = services.GetRequiredService<IService>();
            // Issue request to halver
            double half = service.GetRequired<double, double>(10.0);
        }
        {
            // Service collection
            // <02>
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers(ServiceHandlers.Instance);
            // </02>
            // Avalanche.Service
            serviceCollection
                .AddHandlers(ServiceHandlers.Instance.ServiceRequestHandler)
                .AddCachePolicy(CachePolicies.Default)
                .AddEntryPolicy(EntryPolicies.Default)
                .AddHandler(new Halver())
                .AddAvalancheService();
            // Services
            using var services = serviceCollection.BuildServiceProvider();
            // Get avalanche service
            IService service = services.GetRequiredService<IService>();
            // Issue request to halver
            double half = service.GetRequired<double, double>(10.0);
        }
        {
            // Service collection
            // <03>
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers((ServiceHandlers.Instance.ServiceRequestHandler, new Halver()));
            // </03>
            // Avalanche.Service
            serviceCollection
                .AddHandlers(ServiceHandlers.Instance.ServiceRequestHandler)
                .AddCachePolicy(CachePolicies.Default)
                .AddEntryPolicy(EntryPolicies.Default)
                .AddAvalancheService();
            // Services
            using var services = serviceCollection.BuildServiceProvider();
            // Get avalanche service
            IService service = services.GetRequiredService<IService>();
            // Issue request to halver
            double half = service.GetRequired<double, double>(10.0);
        }

        {
            // Service collection
            // <04>
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandler<Halver>();
            // </04>
            // Avalanche.Service
            serviceCollection
                .AddHandlers(ServiceHandlers.Instance.ServiceRequestHandler)
                .AddCachePolicy(CachePolicies.Default)
                .AddEntryPolicy(EntryPolicies.Default)
                .AddAvalancheService();
            // Services
            using var services = serviceCollection.BuildServiceProvider();
            // Get avalanche service
            IService service = services.GetRequiredService<IService>();
            // Issue request to halver
            double half = service.GetRequired<double, double>(10.0);
        }

        {
            // Service collection
            // <05>
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers<ServiceHandlers>();
            // </05>
            // Avalanche.Service
            serviceCollection
                .AddHandlers(ServiceHandlers.Instance.ServiceRequestHandler)
                .AddHandler<Halver>()
                .AddCachePolicy(CachePolicies.Default)
                .AddEntryPolicy(EntryPolicies.Default)
                .AddAvalancheService();
            // Services
            using var services = serviceCollection.BuildServiceProvider();
            // Get avalanche service
            IService service = services.GetRequiredService<IService>();
            // Issue request to halver
            double half = service.GetRequired<double, double>(10.0);
        }

        // Delegate Handlers
        {
            // <11>
            // Create sum calculator
            Action<IQuery<(int, int), int>> sumCalculator = q => q.Response.SetValue(q.Request.Item1 + q.Request.Item2);
            // Service collection
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers(ServiceHandlers.Instance)
                .AddHandler(sumCalculator);
            // Services
            using var services = serviceCollection.BuildAvalancheServiceProvider();
            // Get avalanche service
            IService service = services.GetRequiredService<IService>();
            // Issue request to sumHandler
            int sum = service.GetRequired<(int, int), int>((5, 6));
            // </11>
        }
        {
            // Create sum calculator
            Action<IQuery<(int, int), int>> sumCalculator = q => q.Response.SetValue(q.Request.Item1 + q.Request.Item2);
            // <12>
            // Create query logger
            static void queryLogger(IQuery q) => WriteLine(Services.MessageDescription.GoodQueryCompleted.Template.Print(null, new object?[] { q.Request, q.Response.Value(), q.Response.Status }));
            // Service collection
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers(ServiceHandlers.Instance)
                .AddHandler(queryLogger, order: long.MaxValue)
            // </12>
                    .AddHandler(sumCalculator);
            // Services
            using var msService = serviceCollection.BuildAvalancheServiceProvider();
            // Get avalanche service
            IService avaService = msService.GetRequiredService<IService>();
            // Issue request to sumHandler
            int sum = avaService.GetRequired<(int, int), int>((5, 6));
        }

        {
            // <21>
            // Create service collection
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers(ServiceHandlers.Instance.ServiceRequestHandler)
                .AddSingleton<MyClass>()
                .AddHandler<MyClassAccessor>();
            // Create service
            using var service = serviceCollection.BuildAvalancheServiceProvider();
            // </21>
        }
        {
            // <22>
            // Create service collection
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers(ServiceHandlers.Instance.ServiceRequestHandler)
                .AddAvalancheService()
                .AddSingleton<MyClass>()
                .AddHandler<MyClassAccessor>();
            // Create service
            using var service = serviceCollection.BuildServiceProvider();
            // </22>
            //
            IServiceProvider msService = service.GetService<IServiceProvider>()!;
            IService avService = service.GetService<IService>()!;
            avService.Get<string, Type>("String");
        }

        {
            // <13>
            // Create async handler
            static async Task urlDownloader(IQuery<string, string> q)
            {
                HttpResponseMessage msg = await new HttpClient().GetAsync(q.Request);
                String content = await msg.Content.ReadAsStringAsync();
                q.Response.SetValue(content);
            }
            // Avalanche.Service
            IServiceCollection serviceCollection =
                new ServiceCollection()
                .AddHandlers(ServiceHandlers.Instance)
                .AddHandler((Func<IQuery<string, string>, Task>)urlDownloader);
            // Services
            using var services = serviceCollection.BuildAvalancheServiceProvider();
            // Get avalanche service
            IService service = services.GetRequiredService<IService>();
            // Get content
            string? content = await service.GetAsync<string, string>("http://avalanche.fi");
            // Print
            Console.WriteLine(content);
            // </13>
        }

        {
            // Create sum calculator
            Action<IQuery<(int, int), int>> sumCalculator = q => q.Response.SetValue(q.Request.Item1 + q.Request.Item2);
            // <14>
            // Create query logger async
            static async Task queryLogger(IQuery q) => await Out.WriteLineAsync(Services.MessageDescription.GoodQueryCompleted.Template.Print(null, new object?[] { q.Request, q.Response.Value(), q.Response.Status }));
            // Service collection
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddHandlers(ServiceHandlers.Instance)
                .AddHandler(queryLogger, order: long.MaxValue)
            // </14>
                    .AddHandler(sumCalculator);
            // Services
            using var msService = serviceCollection.BuildAvalancheServiceProvider();
            // Get avalanche service
            IService avaService = msService.GetRequiredService<IService>();
            // Issue request to sumHandler
            int sum = avaService.GetRequired<(int, int), int>((5, 6));
        }


        {
            // <51>
            // Create service descriptor
            ServiceDescriptor serviceDescriptor = ServiceDescriptor.Singleton<MyClass, MyClass>();
            // 
            IHandlerBase serviceDescriptorHandler = ServiceDescriptorExtensions.ToHandler(serviceDescriptor);
            // </51>
        }

        {
            // <52>
            // Create service descriptors
            IServiceCollection serviceCollection = new ServiceCollection()
                .AddSingleton<MyClass>();
            // 
            IEnumerable<IHandlerBase> serviceDescriptorHandlers = ServiceDescriptorExtensions.ToHandlers(serviceCollection);
            // </52>
        }
    }

    // <Halver>
    public class Halver : IHandler<double, double>
    {
        public void Handle(IQuery<double, double> query)
        {
            // Already handled
            if (query.Handled()) return;
            // Assign result
            query.Response.SetValue(query.Request / 2);
        }
    }
    // </Halver>

    // <MyClass>
    public class MyClass
    {
        IService service;

        public MyClass(IService service)
        {
            this.service = service;
        }
    }
    // </MyClass>

    // <MyClassAccessor>
    public class MyClassAccessor : IHandler<string, Type>
    {
        public void Handle(IQuery<string, Type> query)
        {
            // Use dependency injection
            MyClass myClass = query.Service.GetRequiredService<MyClass>()!;
            // ...
        }
    }
    // </MyClassAccessor>
}