Digging through SignalR - Dependency Resolver

I’m continuing the series of post related to SignalR with dependency injection.
When having a complicated business you can start to group different functionalities in classes. Because of this you can end up very easily with classes that accept in constructor 4-5 or even 10 parameters.

public abstract class PersistentConnection
{
    public PersistentConnection(
        IMessageBus messageBus, IJsonSerializer jsonSerializer, 
        ITraceManager traceManager, IPerformanceCounterManager performanceCounterManager,
        IAckHandler ackHandler, IProtectedData protectedData, 
        IConfigurationManager configurationManager, ITransportManager transportManager,
        IServerCommandHandler serverCommandHandler, HostContext hostContext)
    {
            
    }
    ...
}

Of course you have a decoupled solution that can be tested very easily, but in the same time you have a fat constructor.
People would say: “Well, we have dependency injector, the resolver will handle the constructor and resolve all the dependencies”. This is true, the resolver will inject all the dependencies automatically.
In general, because you don’t want to have a direct dependency to a specific dependency injector stack, people tend to create a wrapper over dependency resolver. The same thing was done in SignalR also.

public interface IDependencyResolver : IDisposable
{
    object GetService(Type serviceType);
    IEnumerable<object> GetServices(Type serviceType);
    void Register(Type serviceType, Func<object> activator);
    void Register(Type serviceType, IEnumerable<Func<object>> activators);
}

Additionally, they done something more. In ctor, they don’t send all the dependencies that are already register in the IoC container. They send directly the dependency resolver, which will be used by the class itself to resolve all the external dependencies.

public abstract class PersistentConnection
{
    public PersistentConnection(IDependencyResolver resolver, HostContext hostContext)
    {
        Initialize(resolver, hostContext);
    }

    public virtual void Initialize(IDependencyResolver resolver, HostContext context)
    {
        ...
        MessageBus = resolver.Resolve<IMessageBus>();
        JsonSerializer = resolver.Resolve<IJsonSerializer>();
        TraceManager = resolver.Resolve<ITraceManager>();
        Counters = resolver.Resolve<IPerformanceCounterManager>();
        AckHandler = resolver.Resolve<IAckHandler>();
        ProtectedData = resolver.Resolve<IProtectedData>();

        _configurationManager = resolver.Resolve<IConfigurationManager>();
        _transportManager = resolver.Resolve<ITransportManager>();
        _serverMessageHandler = resolver.Resolve<IServerCommandHandler>();
        ...
    }

    ...
}

It is important to notify that you don’t need to inject everything through the resolver. You can have specific dependencies injected directly by constructor. For example, HostContext is something specific for each connection. Because of this is more natural to send this context using the constructor. Is something variable that is changing from one connection to another.
Why is the best approach to this problem?
It cannot say that one is better than another. Using this solution, the constructor itself will be lighter, but in the same time you add dependency to the resolver. In a perfect world you shouldn’t have constructors with 7-10 parameters… but when you have cases like this, this solution could be pretty interesting.

Read More

Digging through SignalR - Commands

Looking over source code of SignalR. I found some interesting class and ways to implement different behaviors. In the next series of post I will share with you what I found interesting.
Before starting, you should know that SignalR is an open source project that can be accessed using GitHub.
In today post we will talk about command pattern. This patterns over the ability to define a “macro”/command that can be executed without knowing the caller. Commands can be handle in different ways, from create a queue of them to combining or offering support for redo/undo.
In SignalR library I found an implementation of command pattern that caught my attention.

internal interface ICommand
{
    string DisplayName { get; }
    string Help { get; }
    string[] Names { get; }
    void Execute(string[] args);
}
internal abstract class Command : ICommand
{
    public Command(Action<string> info, Action<string> success, Action<string> warning, Action<string> error)
    {
        Info = info;
        Success = success;
        Warning = warning;
        Error = error;
    }

    public abstract string DisplayName { get; }

    public abstract string Help { get; }

    public abstract string[] Names { get; }

    public abstract void Execute(string[] args);

    protected Action<string> Info { get; private set; }

    protected Action<string> Success { get; private set; }

    protected Action<string> Warning { get; private set; }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "May be used in future derivations.")]
    protected Action<string> Error { get; private set; }
}

Why? The way how the handlers for actions like success, warning, info and error are transmitted. When creating the command, you need to specify them through the construct. In this way the developer will be forced to specify them. I think that this a great and simple way to specify them. If a developer don’t want to handle this actions, that he can transmit a null value for them. This solution is better than having one or more events.
Maybe it would be pretty interesting to wrap this 4 parameters in a simple class. In this way you could have all the similar actions under the same object. Beside this we would reduce the numbers of parameters of the Command class with 3.

internal class CommandCallbackActions
{
    public CommandCallbackActions(Action<string> info, Action<string> success, Action<string> warning, Action<string> error)
    {
        Info = info;
        Success = success;
        Warning = warning;
        Error = error;
    }
    
    protected Action<string> Info { get; private set; }

    protected Action<string> Success { get; private set; }

    protected Action<string> Warning { get; private set; }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "May be used in future derivations.")]
    protected Action<string> Error { get; private set; }
}

internal abstract class Command : ICommand
{   
    public Command(CommandCallbackActions callbackActions)
    {
        CallbackActions = callbackActions;
    }

    public abstract string DisplayName { get; }

    public abstract string Help { get; }

    public abstract string[] Names { get; }

    public abstract void Execute(string[] args);

    public CommandCallbackActions CallbackActions { get; set; }
}

Another method that drew my attention was the “Execute” command. The command arguments are send through an array of string. This is a very and simple and robust way to send parameters. If this is enough for your application, than you should not change this to something more complicated. Otherwise you can replace the array of arguments with an interface (“ICommandArgs”). Each custom command can have his implementation of this interface. You should use this only if you really need, otherwise you will only make the project more complicated.

Read More