IGet.GetAll 1.0.0

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);

Try it out

The examples above give an idea of how you can be creative with IGet and IGet.GetAll. Share your own examples online to spread the word about IGet and IGet.GetAll.

If you're interested in the source code of this library, then use IGet in Visual Studio and press F12 with your cursor on the AddIGetAll() extension method.