public virtual void Register(IRegistration registration)
 {
     lock (_registrationListLock)
     {
         _registrationList.Add(registration);
     }
 }

        public void Register(IRegistration registration)
        {
            _log.Debug("Enter Register");

            // first, get the topology based on the registration info
            RoutingInfo routing = _topoSvc.GetRoutingInfo(registration.Info);

            // next, pull out all the consumer exchanges
            IEnumerable<Exchange> exchanges =
                from route in routing.Routes
                select route.ConsumerExchange;

            foreach (Exchange ex in exchanges)
            {
                IConnection conn = _connFactory.ConnectTo(ex);

                // create a listener
                RabbitListener listener = new RabbitListener(registration, ex, conn);
                listener.OnEnvelopeReceived += this.listener_OnEnvelopeReceived;
                listener.OnClose += _listeners.Remove;

                // put it on another thread so as not to block this one
                Thread listenerThread = new Thread(listener.Start);
                listenerThread.Name = string.Format("{0} on {1}:{2}{3}", ex.QueueName, ex.HostName, ex.Port, ex.VirtualHost);
                listenerThread.Start();

                // store the listener
                _listeners.Add(registration, listener);
            }

            _log.Debug("Leave Register");
        }

        public override void Register(IServiceLocatorAdapter adapter, IServiceLocatorStore store, IRegistration registration, ResolutionPipeline pipeline)
        {
            var mappedFromType = registration.GetMappedFromType();
            var mappedToType = registration.GetMappedToType();

            if (mappedFromType != mappedToType)
            {
                adapter.RegisterFactoryMethod(mappedFromType, () => pipeline.Execute(mappedFromType));
                RegisterLazy(adapter, mappedFromType, pipeline);
                adapter.Register(mappedToType, mappedToType);
                RegisterContextual(adapter, mappedToType);
            }
            else
            {
                var serviceLocator = adapter.GetInstance<IServiceLocator>();
                adapter.RegisterFactoryMethod(mappedToType, () =>
                {
                    var instance = serviceLocator.GetInstance(mappedToType, "default." + mappedToType, new IResolutionArgument[0]);
                    return instance;
                });
                serviceLocator.Register(new NamedRegistration(mappedToType, mappedToType, "default." + mappedToType));
            }

            RegisterLazy(adapter, mappedToType, pipeline);
            RegisterTypeResolver(adapter, mappedFromType);
            RegisterContextual(adapter, mappedFromType);
        }

        public void Add(IRegistration registration)
        {
            if (registration.Key == null)
            {
                // Default
                _defaultIndex.Add(registration.Type, registration);
            }
            else
            {
                // Keyed

                Dictionary<object, IRegistration> keyedEntry;
                if (_keyedIndex.TryGetValue(registration.Type, out keyedEntry))
                {
                    // Add to already existing entry
                    keyedEntry.Add(registration.Key, registration);
                }
                else
                {
                    // Add new keyed entry
                    keyedEntry = new Dictionary<object, IRegistration>();
                    keyedEntry.Add(registration.Key, registration);
                    _keyedIndex.Add(registration.Type, keyedEntry);
                }
            }
        }

 public virtual void Unregister(IRegistration registration)
 {
     lock (_registrationListLock)
     {
         _registrationList.Remove(registration);
     }
 }

        protected RabbitListener createListener(IRegistration registration, Exchange exchange)
        {
            // create a channel
            var connection = _connFactory.ConnectTo(exchange);

            // create a listener
            RabbitListener listener = new RabbitListener(registration, exchange, connection);
            listener.OnEnvelopeReceived += dispatcher =>
                {
                    Log.Debug("Got an envelope from the RabbitListener: dispatching.");
                    // the dispatcher encapsulates the logic of giving the envelope to handlers
                    dispatcher.Dispatch();
                };
            listener.OnClose += _listeners.Remove;

            //TODO: Resolve that RabbitListener does not implement OnConnectionError
            //listener.OnConnectionError(new ReconnectOnConnectionErrorCallback(_channelFactory));

            // store the listener
            _listeners.Add(registration, listener);

            // put it on another thread so as not to block this one
            // don't continue on this thread until we've started listening
            ManualResetEvent startEvent = new ManualResetEvent(false);
            Thread listenerThread = new Thread(listener.Start);
            listenerThread.Name = string.Format("{0} on {1}:{2}{3}", exchange.QueueName, exchange.HostName, exchange.Port, exchange.VirtualHost);
            listenerThread.Start(startEvent);

            return listener;
        }

        /// <summary>
        ///     Initializes a new instance of the <see cref="TeamProjects" /> class.
        /// </summary>
        /// <param name="tfsCollectionUri">The TFS collection URI.</param>
        /// <param name="tfsCredentials">The TFS credentials.</param>
        public TeamProjects(Uri tfsCollectionUri, ITfsCredentials tfsCredentials)
        {
            this._tfsCollectionUri = tfsCollectionUri;
            this._tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tfsCollectionUri, tfsCredentials);

            this._registration = (IRegistration)this._tfsTeamProjectCollection.GetService(typeof(IRegistration));
            this._commonStructureService = this._tfsTeamProjectCollection.GetService<ICommonStructureService>();
        }

 public PropertyFacilityRegistration(IRegistration inner, FinalRegistrationOptions options) {
     if (inner == null)
         throw new ArgumentNullException("inner", "inner is null.");
     if (options == null)
         throw new ArgumentNullException("options", "options is null.");
     _options = options;
     _inner = inner;
 }

        public override object GetInstance(IContainer container, IRegistration registration)
        {
            if (IsDisposed) throw new ObjectDisposedException("ThreadStaticContainerLifecycle");

            var lifecycle = GetThreadStaticLifecycle();

            return lifecycle.GetInstance(container, registration);
        }

        public RabbitListener(IRegistration registration, Exchange exchange, IConnection connection)
        {
            _registration = registration;
            _exchange = exchange;
            _connection = connection;

            _log = LogManager.GetLogger(this.GetType());
        }

        /// <summary>
        /// Removes the instance for the registration from the local storage cache.
        /// </summary>
        /// <param name="registration">The IRegistration returned when the type was registered in the IOC container.</param>
        public void InvalidateInstanceCache(IRegistration registration)
        {
            // nothing stored yet
            if (localStorage == null)
                return;

            localStorage.Remove(registration.Key);
        }

        public FuncNoKeyRegistration(IRegistration delegateRegistration)
        {
            this.delegateRegistration = delegateRegistration;
            this.funcType = Expression.GetFuncType(Type.GetTypeFromHandle(delegateRegistration.TypeHandle)).TypeHandle;

            var registrationContext = Expression.Parameter(typeof(IRegistrationContext), "registrationContext");
            this.generator = Expression.Lambda<Func<IRegistrationContext, object>>(this.GetInstanceExpression(registrationContext), registrationContext).Compile();
        }

 public TeamProjectCollections(Uri tfsUri, ITfsCredentials tfsCredentials)
 {
     this._tfsUri = tfsUri;
     this._tfsCredentials = tfsCredentials;
     this._tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tfsUri, this._tfsCredentials);
     this._tfsConfigurationServer = this._tfsTeamProjectCollection.GetConfigurationServer();
     this._registration = (IRegistration)this._tfsTeamProjectCollection.GetService(typeof(IRegistration));
     this._teamProjectCollectionService = this._tfsConfigurationServer.GetService<ITeamProjectCollectionService>();
 }

        public override void Register(IServiceLocatorAdapter adapter, IServiceLocatorStore store, IRegistration registration, ResolutionPipeline pipeline)
        {
            var namedRegistration = (INamedRegistration)registration;

            var mappedTo = registration.GetMappedTo();

            adapter.RegisterInstanceWithName(registration.GetMappedToType(), mappedTo, namedRegistration.Key);
            adapter.RegisterInstanceWithName(registration.GetMappedFromType(), mappedTo, namedRegistration.Key);
        }

        public void Register(IServiceLocatorAdapter adapter, IServiceLocatorStore store, IRegistration registration, ResolutionPipeline pipeline)
        {
            if (registration is ConstructorRegistration)
            {
                var constructorRegistration = registration as ConstructorRegistration;

                store.Get<IInjectionOverrideStore>().Add(constructorRegistration.Arguments);
            }
        }

        public void Unregister(IRegistration registration)
        {
            RabbitListener listener;

            if (_listeners.TryGetValue(registration, out listener))
            {
                try { listener.Stop(); } catch { }
            }
        }

        public RabbitEnvelopeDispatcher(IRegistration registration, Envelope envelope, IModel channel, ulong deliveryTag)
        {
            _registration = registration;
            _channel = channel;
            _deliveryTag = deliveryTag;

            this.Envelope = envelope;

            _log = LogManager.GetLogger(this.GetType());
        }

		private static string GetMessage(IRegistration registration)
		{
			var msg = "Registration for type: " + registration.ReturnType;

			if (registration.Key != null)
				msg += " with key: " + registration.Key;

			msg += " is invalid.";

			return msg;
		}

        public override void Register(IServiceLocatorAdapter adapter, IServiceLocatorStore store, IRegistration registration, ResolutionPipeline pipeline)
        {
            var mappedFromType = registration.GetMappedFromType();
            var mappedToType = registration.GetMappedToType();

            adapter.RegisterFactoryMethod(mappedFromType, () => pipeline.Execute(mappedFromType));
            adapter.RegisterInstance(mappedToType, registration.GetMappedTo());
            RegisterLazy(adapter, mappedFromType, pipeline);
            RegisterLazy(adapter, mappedToType, pipeline);

            RegisterContextual(adapter, mappedFromType);
            RegisterContextual(adapter, mappedToType);
        }

        public override void Register(IServiceLocatorAdapter adapter, IServiceLocatorStore store, IRegistration registration, ResolutionPipeline pipeline)
        {
            var namedRegistration = (INamedRegistration) registration;

            var mappedToType = registration.GetMappedToType();
            var mappedFromType = registration.GetMappedFromType();

            adapter.RegisterWithName(mappedToType, mappedToType, namedRegistration.Key);
            adapter.RegisterWithName(mappedFromType, mappedToType, namedRegistration.Key);

            RegisterNamedLazy(adapter, mappedFromType, namedRegistration.Key);
            RegisterNamedLazy(adapter, mappedToType, namedRegistration.Key);
        }