public RabbitMQMessageBus(IDependencyResolver resolver, string rabbitMqExchangeName, IModel rabbitMqChannel) : base(resolver)
        {
            _rabbitmqchannel = rabbitMqChannel;
            _rabbitmqExchangeName = rabbitMqExchangeName;

            EnsureConnection();
        }

        public Dispatcher(IDependencyResolver dependencyResolver,
            IJobCoordinator jobCoordinator, IErrorHandlingPolicy errorHandlingPolicy,
            IMethodBinder methodBinder,
            IEventStream eventStream,
            IRecoverableAction recoverableAction,
            IStatusChanger statusChanger,
            IContinuationLiveness continuationLiveness,
            IExceptionFilterDispatcher exceptionFilterDispatcher,
            IJobRootValidator jobRootValidator)
        {
            if (jobCoordinator == null) throw new ArgumentNullException("jobCoordinator");
            if (dependencyResolver == null) throw new ArgumentNullException("dependencyResolver");
            if (errorHandlingPolicy == null) throw new ArgumentNullException("errorHandlingPolicy");
            if (methodBinder == null) throw new ArgumentNullException("methodBinder");
            if (eventStream == null) throw new ArgumentNullException("eventStream");
            if (recoverableAction == null) throw new ArgumentNullException("recoverableAction");
            if (statusChanger == null) throw new ArgumentNullException("statusChanger");
            if (continuationLiveness == null) throw new ArgumentNullException("continuationLiveness");
            if (exceptionFilterDispatcher == null) throw new ArgumentNullException("exceptionFilterDispatcher");
            if (jobRootValidator == null) throw new ArgumentNullException("jobRootValidator");

            _jobCoordinator = jobCoordinator;
            _dependencyResolver = dependencyResolver;
            _errorHandlingPolicy = errorHandlingPolicy;
            _methodBinder = methodBinder;
            _eventStream = eventStream;
            _recoverableAction = recoverableAction;
            _statusChanger = statusChanger;
            _continuationLiveness = continuationLiveness;
            _exceptionFilterDispatcher = exceptionFilterDispatcher;
            _jobRootValidator = jobRootValidator;
        }

        public HubDispatcherRouteHandler(string url, IDependencyResolver resolver)
        {
            _url = VirtualPathUtility.ToAbsolute(url);

            overrideUrlWithPublished();
            _resolver = resolver;
        }

        protected void UseMessageBus(MessageBusType type, IDependencyResolver resolver, int streams = 1)
        {
            IMessageBus bus = null;

            switch (type)
            {
                case MessageBusType.Default:
                    break;
                case MessageBusType.Fake:
                case MessageBusType.FakeMultiStream:
                    bus = new FakeScaleoutBus(resolver, streams);
                    break;
                case MessageBusType.SqlServer:
                    break;
                case MessageBusType.ServiceBus:
                    break;
                case MessageBusType.Redis:
                    break;
                default:
                    break;
            }

            if (bus != null)
            {
                resolver.Register(typeof(IMessageBus), () => bus);
            }
        }

 public ForeverTransport(HostContext context, IDependencyResolver resolver)
     : this(context,
            resolver.Resolve<IJsonSerializer>(),
            resolver.Resolve<ITransportHeartBeat>(),
            resolver.Resolve<IPerformanceCounterManager>())
 {
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="resolver"></param>
 public MessageBus(IDependencyResolver resolver)
     : this(resolver.Resolve<IStringMinifier>(),
            resolver.Resolve<ITraceManager>(),
            resolver.Resolve<IPerformanceCounterManager>(),
            resolver.Resolve<IConfigurationManager>())
 {
 }

 public PersistentConnectionHandler(AppFunc app, string path, Type connectionType, IDependencyResolver resolver)
 {
     _app = app;
     _path = path;
     _connectionType = connectionType;
     _resolver = resolver;
 }

 /// <summary>
 /// Registers a dependency resolver with a given actor system.
 /// </summary>
 /// <param name="system">The actor system in which to register the given dependency resolver.</param>
 /// <param name="dependencyResolver">The dependency resolver being registered to the actor system.</param>
 /// <exception cref="ArgumentNullException">
 /// Either the <paramref name="system"/> or the <paramref name="dependencyResolver"/> was null.
 /// </exception>
 public static void AddDependencyResolver(this ActorSystem system, IDependencyResolver dependencyResolver)
 {
     if (system == null) throw new ArgumentNullException("system");
     if (dependencyResolver == null) throw new ArgumentNullException("dependencyResolver");
     system.RegisterExtension(DIExtension.DIExtensionProvider);
     DIExtension.DIExtensionProvider.Get(system).Initialize(dependencyResolver);
 }

 public UnityBasedDependencyResolver(
     IDependencyResolver baseResolver,
     IUnityContainer unityContainer)
 {
     _baseResolver = baseResolver;
     _unityContainer = unityContainer;
 }

        public ServerCommandHandler(IDependencyResolver resolver) :
            this(resolver.Resolve<IMessageBus>(),
                 resolver.Resolve<IServerIdManager>(),
                 resolver.Resolve<JsonSerializer>())
        {

        }

        public ApplicationOAuthProvider(string publicClientId, IDependencyResolver dependencyResolver)
        {
            Requires.NotNull(dependencyResolver, "dependencyResolver");
            _dependencyResolver = dependencyResolver;

            _publicClientId = publicClientId;
        }

 public ConfiguradorDeDependencias(IDependencyResolver container)
 {
     this.container = container;
     repositorioFactory = new RepositorioFactory(GerenciadorSinais.CaminhoDoArquivoDoRepositorio);
     caracteristicasFactory = new CaracteristicasFactory();
     algoritmoFactory = new AlgoritmoClassificacaoSinalFactory(caracteristicasFactory);
 }

 public LongPollingTransport(HostContext context, IDependencyResolver resolver)
     : this(context,
            resolver.Resolve<IJsonSerializer>(),
            resolver.Resolve<ITransportHeartBeat>(),
            resolver.Resolve<IPerformanceCounterWriter>())
 {
 }

 public DefaultViewPageActivator(IDependencyResolver resolver)
 {
     if (resolver == null)
         _resolverThunk = () => DependencyResolver.Current;
     else
         _resolverThunk = () => resolver;
 }

        internal RedisMessageBus(IDependencyResolver resolver, RedisScaleoutConfiguration configuration, IRedisConnection connection, bool connectAutomatically)
            : base(resolver, configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            _connection = connection;

            _connectionString = configuration.ConnectionString;
            _db = configuration.Database;
            _key = configuration.EventKey;

            var traceManager = resolver.Resolve<ITraceManager>();

            _trace = traceManager["SignalR." + typeof(RedisMessageBus).Name];

            ReconnectDelay = TimeSpan.FromSeconds(2);

            if (connectAutomatically)
            {
                ThreadPool.QueueUserWorkItem(_ =>
                {
                    var ignore = ConnectWithRetry();
                });
            }
        }

 /// <summary>
 /// Initializes new instance of <see cref="Server"/>.
 /// </summary>
 /// <param name="url">The url to host the server on.</param>
 /// <param name="resolver">The dependency resolver for the server.</param>
 public Server(string url, IDependencyResolver resolver)
     : base(resolver)
 {
     _url = url.Replace("*", @".*?");
     _listener = new HttpListener();
     _listener.Prefixes.Add(url);
 }

 public ComparisonService(IRectangleIntersectionService rectangleIntersectionService, IAdjacencyService adjacencyService, IDependencyResolver resolver, IShapeFactory shapeFactory)
 {
     _rectangleIntersectionService = rectangleIntersectionService;
     _adjacencyService = adjacencyService;
     _resolver = resolver;
     _shapeFactory = shapeFactory;
 }

 /// <summary>
 /// Initializes a new instance of <see cref="TransportManager"/> class.
 /// </summary>
 /// <param name="resolver">The default <see cref="IDependencyResolver"/>.</param>
 public TransportManager(IDependencyResolver resolver)
 {
     Register("foreverFrame", context => new ForeverFrameTransport(context, resolver));
     Register("serverSentEvents", context => new ServerSentEventsTransport(context, resolver));
     Register("longPolling", context => new LongPollingTransport(context, resolver));
     Register("webSockets", context => new WebSocketTransport(context, resolver));
 }

        internal BuildManagerViewEngine(IViewPageActivator viewPageActivator, IResolver<IViewPageActivator> activatorResolver,
            IDependencyResolver dependencyResolver, VirtualPathProvider pathProvider)
        {
            if (viewPageActivator != null)
            {
                _viewPageActivator = viewPageActivator;
            }
            else
            {
                _activatorResolver = activatorResolver ?? new SingleServiceResolver<IViewPageActivator>(
                                                              () => null,
                                                              new DefaultViewPageActivator(dependencyResolver),
                                                              "BuildManagerViewEngine constructor");
            }

            if (pathProvider != null)
            {
                Func<VirtualPathProvider> providerFunc = () => pathProvider;
                _fileExistsCache = new FileExistenceCache(providerFunc);
                VirtualPathProviderFunc = providerFunc;
            }
            else
            {
                if (_sharedFileExistsCache == null)
                {
                    // Startup initialization race is OK providing service remains read-only
                    _sharedFileExistsCache = new FileExistenceCache(() => HostingEnvironment.VirtualPathProvider);
                }

                _fileExistsCache = _sharedFileExistsCache;
            }
        }

        private void AddSignalRInjection(IContainer container,IDependencyResolver resolver)
        {
            var updater = new ContainerBuilder();

            updater.RegisterInstance(resolver.Resolve<IConnectionManager>());
            updater.Update(container);
        }