Compartilhar via

Como: implementar um proxy de descoberta

  • Artigo

Este tópico explica como implementar um proxy de descoberta. Para obter mais informações sobre o recurso de descoberta no WCF (Windows Communication Foundation), confira Visão geral da descoberta do WCF. Um proxy de descoberta pode ser implementado criando uma classe que estende a classe abstrata DiscoveryProxy. Há várias outras classes de suporte definidas e usadas neste exemplo. OnResolveAsyncResult, OnFindAsyncResulte AsyncResult. Essas três classes implementam a interface IAsyncResult. Para obter mais informações sobre a interface IAsyncResult confira System.IAsyncResult.

Neste tópico, a implementação de um proxy de descoberta é dividida em três partes principais:

  • Defina uma classe que contém um armazenamento de dados e estenda a classe abstrata DiscoveryProxy.

  • Implemente a classe auxiliar AsyncResult.

  • Hospede o proxy de descoberta.

Para criar um novo projeto de aplicativo de console

  1. Inicie o Visual Studio 2012.

  2. Crie um novo projeto de aplicativo de console. Nomeie o projeto DiscoveryProxy e a solução DiscoveryProxyExample.

  3. Adicione as seguintes referências ao projeto

    1. System.ServiceModel.dll

    2. System.Servicemodel.Discovery.dll

    Cuidado

    Verifique se você faz referência à versão 4.0 ou superior desses assemblies.

Para implementar a classe ProxyDiscoveryService

  1. Adicione um novo arquivo de código ao seu projeto e nomeie-o DiscoveryProxy.cs.

  2. Adicione as diretivas using a seguir para DiscoveryProxy.cs.

    using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Discovery;
using System.Xml;

  3. Derive o DiscoveryProxyService de DiscoveryProxy. Aplique o atributo à classe ServiceBehavior conforme mostra o exemplo a seguir.

    // Implement DiscoveryProxy by extending the DiscoveryProxy class and overriding the abstract methods
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class DiscoveryProxyService : DiscoveryProxy
{
}

  4. Dentro da classe DiscoveryProxy, defina um dicionário para manter os serviços registrados.

    // Repository to store EndpointDiscoveryMetadata.
Dictionary<EndpointAddress, EndpointDiscoveryMetadata> onlineServices;

  5. Defina um construtor que inicializa o dicionário.

    public DiscoveryProxyService()
        {
            this.onlineServices = new Dictionary<EndpointAddress, EndpointDiscoveryMetadata>();
        }

Para definir os métodos usados para atualizar o cache de proxy de descoberta

  1. Implemente o método AddOnlineservice para adicionar serviços ao cache. Isso é chamado sempre que o proxy recebe uma mensagem de anúncio.

    void AddOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
    lock (this.onlineServices)
    {
        this.onlineServices[endpointDiscoveryMetadata.Address] = endpointDiscoveryMetadata;
    }

    PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Adding");
}

  2. Implemente o método RemoveOnlineService usado para remover serviços do cache.

    void RemoveOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
    if (endpointDiscoveryMetadata != null)
    {
        lock (this.onlineServices)
        {
            this.onlineServices.Remove(endpointDiscoveryMetadata.Address);
        }

        PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Removing");
    }
}

  3. Implemente os métodos MatchFromOnlineService que tentam corresponder um serviço com um serviço no dicionário.

    void MatchFromOnlineService(FindRequestContext findRequestContext)
{
    lock (this.onlineServices)
    {
        foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
        {
            if (findRequestContext.Criteria.IsMatch(endpointDiscoveryMetadata))
            {
                findRequestContext.AddMatchingEndpoint(endpointDiscoveryMetadata);
            }
        }
    }
}

    EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria)
{
    EndpointDiscoveryMetadata matchingEndpoint = null;
    lock (this.onlineServices)
    {
        foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
        {
            if (criteria.Address == endpointDiscoveryMetadata.Address)
            {
                matchingEndpoint = endpointDiscoveryMetadata;
            }
        }
    }
    return matchingEndpoint;
}

  4. Implemente o método PrintDiscoveryMetadata que fornece ao usuário a saída de texto do console sobre o que o proxy de descoberta está fazendo.

    void PrintDiscoveryMetadata(EndpointDiscoveryMetadata endpointDiscoveryMetadata, string verb)
{
    Console.WriteLine("\n**** " + verb + " service of the following type from cache. ");
    foreach (XmlQualifiedName contractName in endpointDiscoveryMetadata.ContractTypeNames)
    {
        Console.WriteLine("** " + contractName.ToString());
        break;
    }
    Console.WriteLine("**** Operation Completed");
}

  5. Adicione as seguintes classes AsyncResult ao DiscoveryProxyService. Essas classes são usadas para diferenciar entre os diferentes resultados de operação assíncrona.

    sealed class OnOnlineAnnouncementAsyncResult : AsyncResult
{
    public OnOnlineAnnouncementAsyncResult(AsyncCallback callback, object state)
        : base(callback, state)
    {
        this.Complete(true);
    }

    public static void End(IAsyncResult result)
    {
        AsyncResult.End<OnOnlineAnnouncementAsyncResult>(result);
    }
}

sealed class OnOfflineAnnouncementAsyncResult : AsyncResult
{
    public OnOfflineAnnouncementAsyncResult(AsyncCallback callback, object state)
        : base(callback, state)
    {
        this.Complete(true);
    }

    public static void End(IAsyncResult result)
    {
        AsyncResult.End<OnOfflineAnnouncementAsyncResult>(result);
    }
}

sealed class OnFindAsyncResult : AsyncResult
{
    public OnFindAsyncResult(AsyncCallback callback, object state)
        : base(callback, state)
    {
        this.Complete(true);
    }

    public static void End(IAsyncResult result)
    {
        AsyncResult.End<OnFindAsyncResult>(result);
    }
}

sealed class OnResolveAsyncResult : AsyncResult
{
    EndpointDiscoveryMetadata matchingEndpoint;

    public OnResolveAsyncResult(EndpointDiscoveryMetadata matchingEndpoint, AsyncCallback callback, object state)
        : base(callback, state)
    {
        this.matchingEndpoint = matchingEndpoint;
        this.Complete(true);
    }

    public static EndpointDiscoveryMetadata End(IAsyncResult result)
    {
        OnResolveAsyncResult thisPtr = AsyncResult.End<OnResolveAsyncResult>(result);
        return thisPtr.matchingEndpoint;
    }
}

Para definir os métodos que implementam a funcionalidade de proxy de descoberta

  1. Substitua o método DiscoveryProxy.OnBeginOnlineAnnouncement. Esse método é chamado quando o proxy de descoberta recebe uma mensagem de anúncio online.

    // 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)
{
    this.AddOnlineService(endpointDiscoveryMetadata);
    return new OnOnlineAnnouncementAsyncResult(callback, state);
}

  2. Substitua o método DiscoveryProxy.OnEndOnlineAnnouncement. Esse método é chamado quando o proxy de descoberta termina de processar uma mensagem de anúncio.

    protected override void OnEndOnlineAnnouncement(IAsyncResult result)
{
    OnOnlineAnnouncementAsyncResult.End(result);
}

  3. Substitua o método DiscoveryProxy.OnBeginOfflineAnnouncement. Esse método é chamado quando o proxy de descoberta recebe uma mensagem de anúncio offline.

    // OnBeginOfflineAnnouncement method is called when a Bye message is received by the Proxy
protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
{
    this.RemoveOnlineService(endpointDiscoveryMetadata);
    return new OnOfflineAnnouncementAsyncResult(callback, state);
}

  4. Substitua o método DiscoveryProxy.OnEndOfflineAnnouncement. Esse método é chamado quando o proxy de descoberta termina de processar uma mensagem de anúncio offline.

    protected override void OnEndOfflineAnnouncement(IAsyncResult result)
{
    OnOfflineAnnouncementAsyncResult.End(result);
}

  5. Substitua o método DiscoveryProxy.OnBeginFind. Esse método é chamado quando o proxy de descoberta recebe uma solicitação de localização.

    // OnBeginFind method is called when a Probe request message is received by the Proxy
protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
    this.MatchFromOnlineService(findRequestContext);
    return new OnFindAsyncResult(callback, state);
}
protected override IAsyncResult OnBeginFind(FindRequest findRequest, AsyncCallback callback, object state)
{
    Collection<EndpointDiscoveryMetadata> matchingEndpoints = MatchFromCache(findRequest.Criteria);
    return new OnFindAsyncResult(
                matchingEndpoints,
                callback,
                state);
}

  6. Substitua o método DiscoveryProxy.OnEndFind. Esse método é chamado quando o proxy de descoberta termina de processar uma solicitação de localização.

    protected override void OnEndFind(IAsyncResult result)
{
    OnFindAsyncResult.End(result);
}

  7. Substitua o método DiscoveryProxy.OnBeginResolve. Esse método é chamado quando o proxy de descoberta recebe uma mensagem de resolução.

    // OnBeginFind method is called when a Resolve request message is received by the Proxy
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)
{
    return new OnResolveAsyncResult(this.MatchFromOnlineService(resolveCriteria), callback, state);
}
protected override IAsyncResult OnBeginResolve(ResolveRequest resolveRequest, AsyncCallback callback, object state)
{
    return new OnResolveAsyncResult(
        this.proxy.MatchFromOnlineService(resolveRequest.Criteria),
        callback,
        state);
}

  8. Substitua o método DiscoveryProxy.OnEndResolve. Esse método é chamado quando o proxy de descoberta termina de processar uma mensagem de resolução.

    protected override EndpointDiscoveryMetadata OnEndResolve(IAsyncResult result)
{
    return OnResolveAsyncResult.End(result);
}

Os métodos OnBegin.. / OnEnd.. fornecem a lógica para as operações de descoberta subsequentes. Por exemplo, os métodos OnBeginFind e OnEndFind implementam a lógica de localização para proxy de descoberta. Quando o proxy de descoberta recebe uma mensagem de investigação, esses métodos são executados para enviar uma resposta de volta ao cliente. Você pode modificar a lógica de localização como desejar, por exemplo, você pode incorporar a correspondência de escopo personalizado por algoritmos ou análise de metadados XML específicos do aplicativo como parte de sua operação de localização.

Para implementar a classe AsyncResult

  1. Defina a classe base abstrata AsyncResult que é usada para derivar as várias classes de resultado assíncronas.

  2. Crie um novo arquivo de código chamado AsyncResult.cs.

  3. Adicione as diretivas using a seguir para AsyncResult.cs.

    using System;
using System.Threading;

  4. Adicione a classe AsyncResult a seguir.

    abstract class AsyncResult : IAsyncResult
{
    AsyncCallback callback;
    bool completedSynchronously;
    bool endCalled;
    Exception exception;
    bool isCompleted;
    ManualResetEvent manualResetEvent;
    object state;
    object thisLock;

    protected AsyncResult(AsyncCallback callback, object state)
    {
        this.callback = callback;
        this.state = state;
        this.thisLock = new object();
    }

    public object AsyncState
    {
        get
        {
            return state;
        }
    }

    public WaitHandle AsyncWaitHandle
    {
        get
        {
            if (manualResetEvent != null)
            {
                return manualResetEvent;
            }
            lock (ThisLock)
            {
                manualResetEvent ??= new ManualResetEvent(isCompleted);
            }
            return manualResetEvent;
        }
    }

    public bool CompletedSynchronously
    {
        get
        {
            return completedSynchronously;
        }
    }

    public bool IsCompleted
    {
        get
        {
            return isCompleted;
        }
    }

    object ThisLock
    {
        get
        {
            return this.thisLock;
        }
    }

    protected static TAsyncResult End<TAsyncResult>(IAsyncResult result)
        where TAsyncResult : AsyncResult
    {
        if (result == null)
        {
            throw new ArgumentNullException("result");
        }

        TAsyncResult asyncResult = result as TAsyncResult;

        if (asyncResult == null)
        {
            throw new ArgumentException("Invalid async result.", "result");
        }

        if (asyncResult.endCalled)
        {
            throw new InvalidOperationException("Async object already ended.");
        }

        asyncResult.endCalled = true;

        if (!asyncResult.isCompleted)
        {
            asyncResult.AsyncWaitHandle.WaitOne();
        }

        if (asyncResult.manualResetEvent != null)
        {
            asyncResult.manualResetEvent.Close();
        }

        if (asyncResult.exception != null)
        {
            throw asyncResult.exception;
        }

        return asyncResult;
    }

    protected void Complete(bool completedSynchronously)
    {
        if (isCompleted)
        {
            throw new InvalidOperationException("This async result is already completed.");
        }

        this.completedSynchronously = completedSynchronously;

        if (completedSynchronously)
        {
            this.isCompleted = true;
        }
        else
        {
            lock (ThisLock)
            {
                this.isCompleted = true;
                if (this.manualResetEvent != null)
                {
                    this.manualResetEvent.Set();
                }
            }
        }

        if (callback != null)
        {
            callback(this);
        }
    }

    protected void Complete(bool completedSynchronously, Exception exception)
    {
        this.exception = exception;
        Complete(completedSynchronously);
    }
}

Para hospedar o DiscoveryProxy

  1. Abra o arquivo Program.cs no projeto DiscoveryProxyExample.

  2. Adicione as diretivas using a seguir.

    using System;
using System.ServiceModel;
using System.ServiceModel.Discovery;

  3. No método Main(), adicione o código a seguir. Ele cria uma instância da classe DiscoveryProxy.

    Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
Uri announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");

// Host the DiscoveryProxy service
ServiceHost proxyServiceHost = new ServiceHost(new DiscoveryProxyService());

  4. Em seguida, adicione o código a seguir para adicionar um ponto de extremidade de descoberta e um ponto de extremidade de anúncio.

    try
{
    // Add DiscoveryEndpoint to receive Probe and Resolve messages
    DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress(probeEndpointAddress));
    discoveryEndpoint.IsSystemEndpoint = false;

    // Add AnnouncementEndpoint to receive Hello and Bye announcement messages
    AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(new NetTcpBinding(), new EndpointAddress(announcementEndpointAddress));

    proxyServiceHost.AddServiceEndpoint(discoveryEndpoint);
    proxyServiceHost.AddServiceEndpoint(announcementEndpoint);

    proxyServiceHost.Open();

    Console.WriteLine("Proxy Service started.");
    Console.WriteLine();
    Console.WriteLine("Press <ENTER> to terminate the service.");
    Console.WriteLine();
    Console.ReadLine();

    proxyServiceHost.Close();
}
catch (CommunicationException e)
{
    Console.WriteLine(e.Message);
}
catch (TimeoutException e)
{
    Console.WriteLine(e.Message);
}

if (proxyServiceHost.State != CommunicationState.Closed)
{
    Console.WriteLine("Aborting the service...");
    proxyServiceHost.Abort();
}

Você concluiu a implementação do proxy de descoberta. Continue em Como implementar um serviço de descoberta que registra no proxy de descoberta.

Exemplo

Esta é a lista completa do código usado neste tópico.

// DiscoveryProxy.cs
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Discovery;
using System.Xml;

namespace Microsoft.Samples.Discovery
{
    // Implement DiscoveryProxy by extending the DiscoveryProxy class and overriding the abstract methods
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
    public class DiscoveryProxyService : DiscoveryProxy
    {
        // Repository to store EndpointDiscoveryMetadata. A database or a flat file could also be used instead.
        Dictionary<EndpointAddress, EndpointDiscoveryMetadata> onlineServices;

        public DiscoveryProxyService()
        {
            this.onlineServices = new Dictionary<EndpointAddress, 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)
        {
            this.AddOnlineService(endpointDiscoveryMetadata);
            return new OnOnlineAnnouncementAsyncResult(callback, state);
        }

        protected override void OnEndOnlineAnnouncement(IAsyncResult result)
        {
            OnOnlineAnnouncementAsyncResult.End(result);
        }

        // OnBeginOfflineAnnouncement method is called when a Bye message is received by the Proxy
        protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
        {
            this.RemoveOnlineService(endpointDiscoveryMetadata);
            return new OnOfflineAnnouncementAsyncResult(callback, state);
        }

        protected override void OnEndOfflineAnnouncement(IAsyncResult result)
        {
            OnOfflineAnnouncementAsyncResult.End(result);
        }

        // OnBeginFind method is called when a Probe request message is received by the Proxy
        protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
        {
            this.MatchFromOnlineService(findRequestContext);
            return new OnFindAsyncResult(callback, state);
        }

        protected override void OnEndFind(IAsyncResult result)
        {
            OnFindAsyncResult.End(result);
        }

        // OnBeginFind method is called when a Resolve request message is received by the Proxy
        protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)
        {
            return new OnResolveAsyncResult(this.MatchFromOnlineService(resolveCriteria), callback, state);
        }

        protected override EndpointDiscoveryMetadata OnEndResolve(IAsyncResult result)
        {
            return OnResolveAsyncResult.End(result);
        }

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

            PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Adding");
        }

        void RemoveOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
        {
            if (endpointDiscoveryMetadata != null)
            {
                lock (this.onlineServices)
                {
                    this.onlineServices.Remove(endpointDiscoveryMetadata.Address);
                }

                PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Removing");
            }
        }

        void MatchFromOnlineService(FindRequestContext findRequestContext)
        {
            lock (this.onlineServices)
            {
                foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
                {
                    if (findRequestContext.Criteria.IsMatch(endpointDiscoveryMetadata))
                    {
                        findRequestContext.AddMatchingEndpoint(endpointDiscoveryMetadata);
                    }
                }
            }
        }

        EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria)
        {
            EndpointDiscoveryMetadata matchingEndpoint = null;
            lock (this.onlineServices)
            {
                foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
                {
                    if (criteria.Address == endpointDiscoveryMetadata.Address)
                    {
                        matchingEndpoint = endpointDiscoveryMetadata;
                    }
                }
            }
            return matchingEndpoint;
        }

        void PrintDiscoveryMetadata(EndpointDiscoveryMetadata endpointDiscoveryMetadata, string verb)
        {
            Console.WriteLine("\n**** " + verb + " service of the following type from cache. ");
            foreach (XmlQualifiedName contractName in endpointDiscoveryMetadata.ContractTypeNames)
            {
                Console.WriteLine("** " + contractName.ToString());
                break;
            }
            Console.WriteLine("**** Operation Completed");
        }

        sealed class OnOnlineAnnouncementAsyncResult : AsyncResult
        {
            public OnOnlineAnnouncementAsyncResult(AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.Complete(true);
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<OnOnlineAnnouncementAsyncResult>(result);
            }
        }

        sealed class OnOfflineAnnouncementAsyncResult : AsyncResult
        {
            public OnOfflineAnnouncementAsyncResult(AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.Complete(true);
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<OnOfflineAnnouncementAsyncResult>(result);
            }
        }

        sealed class OnFindAsyncResult : AsyncResult
        {
            public OnFindAsyncResult(AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.Complete(true);
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<OnFindAsyncResult>(result);
            }
        }

        sealed class OnResolveAsyncResult : AsyncResult
        {
            EndpointDiscoveryMetadata matchingEndpoint;

            public OnResolveAsyncResult(EndpointDiscoveryMetadata matchingEndpoint, AsyncCallback callback, object state)
                : base(callback, state)
            {
                this.matchingEndpoint = matchingEndpoint;
                this.Complete(true);
            }

            public static EndpointDiscoveryMetadata End(IAsyncResult result)
            {
                OnResolveAsyncResult thisPtr = AsyncResult.End<OnResolveAsyncResult>(result);
                return thisPtr.matchingEndpoint;
            }
        }
    }
}

// AsyncResult.cs
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------

using System;
using System.Threading;

namespace Microsoft.Samples.Discovery
{
    abstract class AsyncResult : IAsyncResult
    {
        AsyncCallback callback;
        bool completedSynchronously;
        bool endCalled;
        Exception exception;
        bool isCompleted;
        ManualResetEvent manualResetEvent;
        object state;
        object thisLock;

        protected AsyncResult(AsyncCallback callback, object state)
        {
            this.callback = callback;
            this.state = state;
            this.thisLock = new object();
        }

        public object AsyncState
        {
            get
            {
                return state;
            }
        }

        public WaitHandle AsyncWaitHandle
        {
            get
            {
                if (manualResetEvent != null)
                {
                    return manualResetEvent;
                }
                lock (ThisLock)
                {
                    manualResetEvent ??= new ManualResetEvent(isCompleted);
                }
                return manualResetEvent;
            }
        }

        public bool CompletedSynchronously
        {
            get
            {
                return completedSynchronously;
            }
        }

        public bool IsCompleted
        {
            get
            {
                return isCompleted;
            }
        }

        object ThisLock
        {
            get
            {
                return this.thisLock;
            }
        }

        protected static TAsyncResult End<TAsyncResult>(IAsyncResult result)
            where TAsyncResult : AsyncResult
        {
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            TAsyncResult asyncResult = result as TAsyncResult;

            if (asyncResult == null)
            {
                throw new ArgumentException("Invalid async result.", "result");
            }

            if (asyncResult.endCalled)
            {
                throw new InvalidOperationException("Async object already ended.");
            }

            asyncResult.endCalled = true;

            if (!asyncResult.isCompleted)
            {
                asyncResult.AsyncWaitHandle.WaitOne();
            }

            if (asyncResult.manualResetEvent != null)
            {
                asyncResult.manualResetEvent.Close();
            }

            if (asyncResult.exception != null)
            {
                throw asyncResult.exception;
            }

            return asyncResult;
        }

        protected void Complete(bool completedSynchronously)
        {
            if (isCompleted)
            {
                throw new InvalidOperationException("This async result is already completed.");
            }

            this.completedSynchronously = completedSynchronously;

            if (completedSynchronously)
            {
                this.isCompleted = true;
            }
            else
            {
                lock (ThisLock)
                {
                    this.isCompleted = true;
                    if (this.manualResetEvent != null)
                    {
                        this.manualResetEvent.Set();
                    }
                }
            }

            if (callback != null)
            {
                callback(this);
            }
        }

        protected void Complete(bool completedSynchronously, Exception exception)
        {
            this.exception = exception;
            Complete(completedSynchronously);
        }
    }
}

// program.cs
//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------

using System;
using System.ServiceModel;
using System.ServiceModel.Discovery;

namespace Microsoft.Samples.Discovery
{
    class Program
    {
        public static void Main()
        {
            Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
            Uri announcementEndpointAddress = new Uri("net.tcp://localhost:9021/Announcement");

            // Host the DiscoveryProxy service
            ServiceHost proxyServiceHost = new ServiceHost(new DiscoveryProxyService());

            try
            {
                // Add DiscoveryEndpoint to receive Probe and Resolve messages
                DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress(probeEndpointAddress));
                discoveryEndpoint.IsSystemEndpoint = false;

                // Add AnnouncementEndpoint to receive Hello and Bye announcement messages
                AnnouncementEndpoint announcementEndpoint = new AnnouncementEndpoint(new NetTcpBinding(), new EndpointAddress(announcementEndpointAddress));

                proxyServiceHost.AddServiceEndpoint(discoveryEndpoint);
                proxyServiceHost.AddServiceEndpoint(announcementEndpoint);

                proxyServiceHost.Open();

                Console.WriteLine("Proxy Service started.");
                Console.WriteLine();
                Console.WriteLine("Press <ENTER> to terminate the service.");
                Console.WriteLine();
                Console.ReadLine();

                proxyServiceHost.Close();
            }
            catch (CommunicationException e)
            {
                Console.WriteLine(e.Message);
            }
            catch (TimeoutException e)
            {
                Console.WriteLine(e.Message);
            }

            if (proxyServiceHost.State != CommunicationState.Closed)
            {
                Console.WriteLine("Aborting the service...");
                proxyServiceHost.Abort();
            }
        }
    }
}

Confira também