SignalR dependency injection via Spring.Net

Question

I'm trying to inject dependencies via Spring.NET.

First I created a custom DependencyResolver:

 public class SignalRSpringNetDependencyResolver : DefaultDependencyResolver
{
    private IApplicationContext _context;

    public SignalRSpringNetDependencyResolver(IApplicationContext context) 
    {
        _context = context;
    }

    /// <summary>
    /// Gets the application context.
    /// </summary>
    /// <value>The application context.</value>
    public IApplicationContext ApplicationContext
    {
        get
        {
            if (_context == null || _context.Name != ApplicationContextName)
            {
                if (string.IsNullOrEmpty(ApplicationContextName))
                {
                    _context = ContextRegistry.GetContext();
                }
                else
                {
                    _context = ContextRegistry.GetContext(ApplicationContextName);
                }
            }

            return _context;
        }
    }

    /// <summary>
    /// Gets or sets the name of the application context.
    /// </summary>
    /// <remarks>
    /// Defaults to using the root (default) Application Context.
    /// </remarks>
    /// <value>The name of the application context.</value>
    public static string ApplicationContextName { get; set; }


    /// <summary>
    /// Resolves singly registered services that support arbitrary object creation.
    /// </summary>
    /// <param name="serviceType">The type of the requested service or object.</param>
    /// <returns>The requested service or object.</returns>
    public override object GetService(Type serviceType)
    {

        System.Diagnostics.Debug.WriteLine(serviceType.FullName);

        if (serviceType != null && !serviceType.IsAbstract && !serviceType.IsInterface && serviceType.IsClass)
        {
            var services = ApplicationContext.GetObjectsOfType(serviceType).GetEnumerator();

            services.MoveNext();

            try
            {
                return services.Value;
            }
            catch (InvalidOperationException)
            {
                return null;
            }

        }

        else 
        {
           return base.GetService(serviceType);
        }

    }

    /// <summary>
    /// Resolves multiply registered services.
    /// </summary>
    /// <param name="serviceType">The type of the requested services.</param>
    /// <returns>The requested services.</returns>
    public override IEnumerable<object> GetServices(Type serviceType)
    {
        var services = ApplicationContext.GetObjectsOfType(serviceType).Cast<object>();

        services.Concat(base.GetServices(serviceType));

        return services;
    }

Note that i escape interfaces and abstract classes so that I will get the default implementations of SignalR from the base DefaultDependencyResolver

and here I assigned the resolver using WebActivator:

        public static void PostStart() 
    {

        // Inject Dependencies to SignalR, should be always come before ASP.NET MVC configuration            
        var dependecyResolver = new SignalRSpringNetDependencyResolver(ContextRegistry.GetContext());
        GlobalHost.DependencyResolver = dependecyResolver;
        RouteTable.Routes.MapHubs();


        AreaRegistration.RegisterAllAreas();
        RegisterGlobalFilters(GlobalFilters.Filters);
        RegisterRoutes(RouteTable.Routes);

    }

However, SignalR is always trying to resolve it's own dependencies using the Resolver i assigned and i get the following error:

'myhub' hub could not be resolved.

I only need the resolver to be aware of other dependencies(my Repository for example) and keep the default implementation of SignalR services.

Erethism

Have you seen the Ninject implementation of DependencyResolver for SignalR? This blog post has some info for SignalR + mvc 3 + Signalr.Ninject. – Aleman

Answer 1

I think it's hard to get Spring.Net working with SignalR

for the current version (Spring.Net 1.3.2) it's difficult to support asynchronous programming. Spring.Net session management doesn't play well with Task<T> types.

I ended up injecting my dependencies in 2 steps:

1- registering the required type on WebActivator PostStart:

GlobalHost.DependencyResolver.Register(
    typeof(IUserService), 
    () => (UserService)ctx.GetObject("UserService"))

2- picking them up in my Hub constructor:

public MyHub() 
{
    _userService =
        DependencyResolver.Current.GetService<IUserService>();
}

Erethism