IGet.GetAll 1.0.0-alpha

IGet.GetAll

Extends IGet. Get an IEnumerable of class instances (with their dependencies injected) via i.GetAll<IMyInterface>() or i.GetAll<MyBaseClass>(). Idea: create a generic notification publisher and use it like i.Get<NotificationPublisher<NotificationA>>().Publish(notification) instead of mediatR.Publish(notification).

using IGetAll;

serviceCollection.AddIGet();
serviceCollection.AddIGetAll(new [] { typeof(Startup).Assembly, ... });

Why?

IGet gets single classes, but cannot provide multiple in one call. If you like MediatR's INotification-INotificationHandler combination then you will probably feel the need for something that automatically collects INotificationHandlers - that is one of the things that i.GetAll<T>() can do - it has the following benefits:

• you declare whatever interfaces and base classes you like; this package does not force you to use pre-defined interfaces.
• after i.GetAll<T>() you explicitly show how you handle exceptions, making your code easier to understand.
• after i.GetAll<T>() you explicitly show that you use Task.WhenAll or foreach with await (or synchronous code).

Also note: no matter how complicated your interfaces or generic base classes are - think about IMyInterface<SomeClass, NestedBaseClass<AnotherClass, AndMore>> - no additional configuration is needed.

About performance

Each time you use i.GetAll<T>() for a new type T the collected Type[] is stored in a ConcurrentDictionary so that when you call i.GetAll<T>() next time for the same type T, no assembly scanning is done.

Example

Declare an interface you like:

public interface INotificationHandler<TNotification>
{
    Task HandleAsync(TNotification notification, CancellationToken cancellationToken);
}

Implement the interface:

public class NotificationA { }

public class HandlerA1 : INotificationHandler<NotificationA>
{
    private readonly ILogger<HandlerA1> _logger;
    public HandlerA1(ILogger<HandlerA1> logger)
    {
        _logger = logger;
    }
    public async Task HandleAsync(NotificationA notification, CancellationToken cancellationToken)
    {
        // do stuff
    }
}

public class HandlerA2 : INotificationHandler<NotificationA>
{
    private readonly IConnectionFactory _connectionFactory;
    public HandlerA2(IConnectionFactory connectionFactory)
    {
        _connectionFactory = connectionFactory;
    }
    public async Task HandleAsync(NotificationA notification, CancellationToken cancellationToken)
    {
        // do stuff
    }
}

public class NotificationB { }

public class HandlerB1 : INotificationHandler<NotificationB>
{
    private readonly ILogger<Handler1> _logger;
    public HandlerB1(ILogger<Handler1> logger)
    {
        _logger = logger;
    }
    public async Task HandleAsync(NotificationB notification, CancellationToken cancellationToken)
    {
        // do stuff
    }
}

Create a generic notification publisher for all your notification types:

public class NotificationPublisher<TNotification> where TNotification : notnull
{
    private readonly ILogger _logger;
    private readonly IGet i;

    public NotificationPublisher(IGet iget, ILogger logger)
    {
        _logger = logger;
        i = iget;
    }

    public async Task Publish(TNotification notification, CancellationToken cancellationToken = default)
    {
        foreach (var handler in i.GetAll<INotificationHandler<TNotification>>())
        {
            try
            {
                await handler.HandleAsync(notification, cancellationToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in {handlerType} for {notificationKeyValuePairs}.", handler.GetType().FullName, notification.ToKeyValuePairsString());
            }
        }
    }
}

Publish notifications:

// invokes HandlerA1 and HandlerA2:
await i.Get<NotificationPublisher<NotificationA>>().Publish(notificationA);
// invokes HandlerB1:
await i.Get<NotificationPublisher<NotificationB>>().Publish(notificationB);