Procedura: implementare un proxy di individuazione

  • Articolo

In questo argomento viene illustrato come implementare un proxy di individuazione. Per altre informazioni sulla funzionalità di individuazione in Windows Communication Foundation (WCF), vedere Panoramica di WCF Discovery. È possibile implementare un proxy di individuazione creando una classe che estende la classe astratta DiscoveryProxy. In questo esempio vengono definite e utilizzate altre classi di supporto. OnResolveAsyncResult, OnFindAsyncResulte AsyncResult. Queste classi implementano l'interfaccia IAsyncResult. Per altre informazioni su IAsyncResult vedere Interfaccia System.IAsyncResult.

In questo argomento l'implementazione di un proxy di individuazione è articolata in tre fasi principali:

  • Definire una classe che contiene un archivio dati ed estende la classe astratta DiscoveryProxy.

  • Implementare la classe di supporto AsyncResult.

  • Ospitare il proxy di individuazione.

Per creare un nuovo progetto di applicazione console

  1. Avviare Visual Studio 2012.

  2. Creare un nuovo progetto di applicazione console. Assegnare al progetto il nome DiscoveryProxy e assegnare alla soluzione il nome DiscoveryProxyExample.

  3. Aggiungere al progetto i riferimenti seguenti

    1. System.ServiceModel.dll

    2. System.Servicemodel.Discovery.dll

    Attenzione

    Accertarsi di fare riferimento alla versione 4.0 o successiva di questi assembly.

Per implementare la classe ProxyDiscoveryService

  1. Aggiungere un nuovo file di codice al progetto e denominarlo DiscoveryProxy.cs.

  2. Aggiungere le istruzioni using seguenti a DiscoveryProxy.cs.

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

  3. Derivare DiscoveryProxyService da DiscoveryProxy. Applicare l'attributo ServiceBehavior alla classe, come illustrato nell'esempio riportato di seguito.

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

  4. Nella classe DiscoveryProxy definire un dizionario per conservare i servizi registrati.

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

  5. Definire un costruttore che inizializza il dizionario.

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

Per definire i metodi utilizzati per aggiornare la cache del proxy di individuazione

  1. Implementare il metodo AddOnlineservice per aggiungere servizi alla cache. Questo metodo viene chiamato ogni volta che il proxy riceve un messaggio di annuncio.

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

    PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Adding");
}

  2. Implementare il metodo RemoveOnlineService utilizzato per rimuovere servizi dalla cache.

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

        PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Removing");
    }
}

  3. Implementare i metodi MatchFromOnlineService, che tentano di individuare una corrispondenza tra un servizio e un servizio nel dizionario.

    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. Implementare il metodo PrintDiscoveryMetadata, che fornisce all'utente l'output di testo della console indicante le operazioni eseguite dal proxy di individuazione.

    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. Aggiungere le classi AsyncResult seguenti a DiscoveryProxyService. Tali classi vengono utilizzate per distinguere i diversi risultati delle operazioni asincrone.

    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;
    }
}

Per definire i metodi che implementano la funzionalità del proxy di individuazione

  1. Eseguire l'override del metodo DiscoveryProxy.OnBeginOnlineAnnouncement. Questo metodo viene chiamato quando il proxy di individuazione riceve un messaggio di annuncio 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. Eseguire l'override del metodo DiscoveryProxy.OnEndOnlineAnnouncement. Questo metodo viene chiamato quando il proxy di individuazione completa l'elaborazione di un messaggio di annuncio.

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

  3. Eseguire l'override del metodo DiscoveryProxy.OnBeginOfflineAnnouncement. Questo metodo viene chiamato quando il proxy di individuazione riceve un messaggio di annuncio 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. Eseguire l'override del metodo DiscoveryProxy.OnEndOfflineAnnouncement. Questo metodo viene chiamato quando il proxy di individuazione completa l'elaborazione di un messaggio di annuncio offline.

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

  5. Eseguire l'override del metodo DiscoveryProxy.OnBeginFind. Questo metodo viene chiamato quando il proxy di individuazione riceve una richiesta di ricerca.

    // 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. Eseguire l'override del metodo DiscoveryProxy.OnEndFind. Questo metodo viene chiamato quando il proxy di individuazione completa l'elaborazione di una richiesta di ricerca.

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

  7. Eseguire l'override del metodo DiscoveryProxy.OnBeginResolve. Questo metodo viene chiamato quando il proxy di individuazione riceve un messaggio di risoluzione.

    // 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. Eseguire l'override del metodo DiscoveryProxy.OnEndResolve. Questo metodo viene chiamato quando il proxy di individuazione completa l'elaborazione di un messaggio di risoluzione.

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

I metodi OnBegin. / OnEnd. forniscono la logica per le operazioni di individuazione successive. I metodi OnBeginFind e OnEndFind implementano ad esempio la logica di ricerca per il proxy di individuazione. Quando il proxy di individuazione riceve un messaggio del probe, questi metodi vengono eseguiti per inviare una risposta al client. È possibile modificare la logica di ricerca in base alle proprie esigenze. È ad esempio possibile incorporare un ambito personalizzato in base ad algoritmi o all'analisi dei metadati XML specifici dell'applicazione nell'ambito dell'operazione di ricerca.

Per implementare la classe AsyncResult

  1. Definire la classe di base astratta AsyncResult, utilizzata per derivare le varie classi AsyncResult.

  2. Creare un nuovo file di codice denominato AsyncResult.cs.

  3. Aggiungere le istruzioni using seguenti a AsyncResult.cs.

    using System;
using System.Threading;

  4. Aggiungere la classe AsyncResult seguente.

    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);
    }
}

Per ospitare DiscoveryProxy

  1. Aprire il file Program.cs nel progetto DiscoveryProxyExample.

  2. Aggiungere le istruzioni using seguenti.

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

  3. Aggiungere nel metodo Main() il codice riportato di seguito. In questo modo viene creata un'istanza della 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. Aggiungere quindi il codice seguente per aggiungere un endpoint di individuazione e un endpoint annunci.

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

L'implementazione del proxy di individuazione è quindi completata. Continuare con Procedura: implementare un servizio individuabile che esegue la registrazione al proxy di individuazione.

Esempio

Quello che segue è l'elenco completo del codice usato in questo argomento.

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

Vedi anche