private void RemoveService(ServiceHost serviceHost, EndpointDiscoveryMetadata endpoint)
		{
			if (IsSelfDiscovery(serviceHost, endpoint) == false)
			{
				serviceCatalog.RemoveService(endpoint);
			}
		}

        public override void RemoveEndpointMetadata(EndpointDiscoveryMetadata metadata)
        {
            var uri = metadata.Address.Uri.AbsoluteUri;
            var addressJson = JsonConvert.SerializeObject(metadata.Address);
            var contractTypeNames = metadata.GetContractTypeNames();
            var bindingTypeName = metadata.GetBindingTypeName();
            using (var conn = _connectionCreator.Invoke(_connectionString))
            {
                var cmd = conn.CreateCommand();
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = "UnRegisterServiceEndpointMetadata";
                cmd.AddParameter("uri", uri)
                    .AddParameter("contractType", null)
                    .AddParameter("address", addressJson)
                    .AddParameter("bindingType", bindingTypeName);

                conn.Open();
                cmd.Transaction = conn.BeginTransaction();
                foreach (var contractTypeName in contractTypeNames)
                {
                    cmd.GetParameter("contractType").Value = contractTypeName;
                    cmd.ExecuteNonQuery();
                }
                cmd.Transaction.Commit();
            }
        }

 internal AnnouncementEventArgs(
     DiscoveryMessageSequence messageSequence, 
     EndpointDiscoveryMetadata endpointDiscoveryMetadata)
 {
     this.MessageSequence = messageSequence;
     this.EndpointDiscoveryMetadata = endpointDiscoveryMetadata;
 }

 internal FindProgressChangedEventArgs(int progressPercentage, object userState,
     EndpointDiscoveryMetadata endpointDiscoveryMetadata, DiscoveryMessageSequence messageSequence)
     : base(progressPercentage, userState)
 {
     this.endpointDiscoveryMetadata = endpointDiscoveryMetadata;
     this.messageSequence = messageSequence;
 }

		public void AnnonceOnlineOfflineNoBinding ()
		{
			var ac = new AnnouncementClient (new AnnouncementEndpoint () { Address = new EndpointAddress ("http://localhost:37564")});
			var edm = new EndpointDiscoveryMetadata ();
			ac.AnnounceOnline (edm);
			// attempt to close the client causes another CommunicationObjectFaultedException - looks like it fails to allow Close() at faulted state unlike other objects.
		}

        public virtual bool RegisterEndpoint(EndpointDiscoveryMetadata endpoint)
        {
			var registered = false;
            if (AcceptEndpoint(endpoint))
            {
				using (var locker = @lock.ForReadingUpgradeable())
				{
					policies.ForEach(policy => registered = registered | policy.RegisterTarget(endpoint));

					locker.Upgrade();

					if (registered == false)
					{
						var newPolicies = policyFactory.CreatePolicies(endpoint);
						Array.ForEach(newPolicies, newPolicy =>
						{
							registered = registered | newPolicy.RegisterTarget(endpoint);
							policies.Add(newPolicy);
						});
					}

					if (registered)
						endpoints[endpoint.Address] = endpoint;
				}
            }
			return registered;
        }

		protected override IAsyncResult OnBeginOfflineAnnouncement(
			DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata,
			AsyncCallback callback, object state)
		{
			implementation.RemoveEndpoint(endpointDiscoveryMetadata);
			return new SynchronousResult(callback, state);
		}

		private void RegisterService(ServiceHost serviceHost, EndpointDiscoveryMetadata endpoint)
		{
			if (FilterService(serviceHost, endpoint) == false)
			{
				serviceCatalog.RegisterService(endpoint);
			}
		}

        protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
        {
            try
            {
                if (endpointDiscoveryMetadata == null)
                {
                    throw new ArgumentNullException("endpointDiscoveryMetadata");
                }

                // We care only about ISimpleChatService services
                FindCriteria criteria = new FindCriteria(typeof(ISimpleChatService));

                if (criteria.IsMatch(endpointDiscoveryMetadata))
                {
                    endpointDiscoveryMetadata.WriteLine("Removing");
                    Cache.Remove(endpointDiscoveryMetadata.Address.Uri);
                }
            }
            catch (KeyNotFoundException)
            {
                // No problem if it does not exist in the cache
            }

            return new CompletedAsyncResult(callback, state);
        }

 private void PopulateUserList(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
 {
     if (!this.EndpointIsSelf(endpointDiscoveryMetadata.Address.Uri))
     {
         this.AddUser(new PeerUser(endpointDiscoveryMetadata.Address));
     }
 }

 //OfflineAnnouncement
 protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
 {
     if (this.Endpoints.ContainsKey(endpointDiscoveryMetadata.Address))
     {
         this.Endpoints.Remove(endpointDiscoveryMetadata.Address);
     }
     return new DiscoveryAsyncResult(callback, state);
 }

        // The following are helper methods required by the Proxy implementation
        void AddOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
        {
            lock (this.onlineServices)
            {
                this.onlineServices[endpointDiscoveryMetadata.Address] = endpointDiscoveryMetadata;
            }

        }

        public virtual void RegisterService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
        {
            if (AcceptService(endpointDiscoveryMetadata))
            {
				services.AddOrUpdate(endpointDiscoveryMetadata.Address, endpointDiscoveryMetadata,
					(address, existing) => endpointDiscoveryMetadata);
            }
        }

        public virtual void RegisterEndpoint(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
        {
            if (AcceptEndpoint(endpointDiscoveryMetadata))
            {
				endpoints.AddOrUpdate(endpointDiscoveryMetadata.Address, endpointDiscoveryMetadata,
					(address, existing) => endpointDiscoveryMetadata);
            }
        }

 // OnBeginOnlineAnnouncement method is called when a Hello message is received by the Proxy
 protected override IAsyncResult OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence,
     EndpointDiscoveryMetadata endpointDiscoveryMetadata,
     AsyncCallback callback, object state)
 {
     _logger.Log("OnBeginOnlineAnnouncement()", LogLevel.Debug);
     _provider.Add(endpointDiscoveryMetadata);
     return new OnOnlineAnnouncementAsyncResult(callback, state);
 }

        public void AddMatchingEndpoint(EndpointDiscoveryMetadata matchingEndpoint) 
        {
            if (matchingEndpoint == null)
            {
                throw FxTrace.Exception.ArgumentNull("matchingEndpoint");
            }

            this.OnAddMatchingEndpoint(matchingEndpoint);
        }

        public MatchedEndpointDiscoveryMetadata(string addressJson, string bindingTypeName, string bindingJson, DateTime updatedOn)
        {
            _metadata = null;

            _addressJson = addressJson;
            _bindingTypeName = bindingTypeName;
            _bindingJson = bindingJson;
            _updatedOn = updatedOn;
        }

 public void Remove(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
 {
     if (endpointDiscoveryMetadata != null)
     {
         OnlineService tmp;
         _onlineServices.TryRemove(endpointDiscoveryMetadata.Address, out tmp);
         _logger.Log("Removing " + endpointDiscoveryMetadata.Address, LogLevel.Debug);
     }
 }

 // The following are helper methods required by the Proxy implementation
 public void AddOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
 {
     lock (_onlineServices)
     {
         _onlineServices[endpointDiscoveryMetadata.Address] = endpointDiscoveryMetadata;
     }
     // Replace with log4net
     //PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Adding");
 }

		public static EndpointDiscoveryMetadata FromServiceEndpoint (ServiceEndpoint endpoint)
		{
			var ret = new EndpointDiscoveryMetadata ();
			ret.ContractTypeNames.Add (new XmlQualifiedName (endpoint.Contract.Name, endpoint.Contract.Namespace));
			ret.Address = endpoint.Address;
			if (endpoint.Address != null)
				ret.ListenUris.Add (endpoint.Address.Uri);

			return ret;
		}