SignalR dependency injection via Spring.Net

问题:

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.

回答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>();
}