Condividi tramite


Procedura: implementare un'applicazione client che utilizza il proxy di individuazione per cercare un servizio

Quello che segue è il terzo di tre argomenti incentrato sull'implementazione di un proxy di individuazione. Nell'argomento precedente, Procedura: implementare un servizio individuabile che esegue la registrazione al proxy di individuazione, è stato implementato un servizio WCF che esegue la registrazione al proxy di individuazione. In questo argomento verrà creato un client WCF che utilizza il proxy di individuazione per cercare il servizio WCF.

Implementare il client

  1. Aggiungere un nuovo progetto applicazione console denominato Client alla soluzione DiscoveryProxyExample.

  2. Aggiungere riferimenti agli assembly indicati di seguito:

    1. System.ServiceModel

    2. System.ServiceModel.Discovery

  3. Aggiungere al progetto il file GeneratedClient.cs individuato nella parte inferiore di questo argomento.

    Dd456785.note(it-it,VS.100).gifNota:
    In genere, questo file viene generato utilizzando uno strumento come Svcutil.exe, fornito nel presente argomento per semplificare l'attività.

  4. Aprire il file Program.cs e aggiungere il metodo seguente. Questo metodo prende un indirizzo endpoint e lo utilizza per inizializzare il client del servizio (proxy).

    static void InvokeCalculatorService(EndpointAddress endpointAddress)
            {
                // Create a client
                CalculatorServiceClient client = new CalculatorServiceClient(new NetTcpBinding(), endpointAddress);
                Console.WriteLine("Invoking CalculatorService at {0}", endpointAddress.Uri);
                Console.WriteLine();
    
                double value1 = 100.00D;
                double value2 = 15.99D;
    
                // Call the Add service operation.
                double result = client.Add(value1, value2);
                Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);
    
                // Call the Subtract service operation.
                result = client.Subtract(value1, value2);
                Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result);
    
                // Call the Multiply service operation.
                result = client.Multiply(value1, value2);
                Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);
    
                // Call the Divide service operation.
                result = client.Divide(value1, value2);
                Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);
                Console.WriteLine();
    
                // Closing the client gracefully closes the connection and cleans up resources
                client.Close();
            }
    
  5. Aggiungere al metodo Main il seguente codice.

    public static void Main()
            {
                // Create a DiscoveryEndpoint that points to the DiscoveryProxy
                Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
                DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress(probeEndpointAddress));
    
                // Create a DiscoveryClient passing in the discovery endpoint
                DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint);
    
                Console.WriteLine("Finding ICalculatorService endpoints using the proxy at {0}", probeEndpointAddress);
                Console.WriteLine();
    
                try
                {
                    // Search for services that implement ICalculatorService            
                    FindResponse findResponse = discoveryClient.Find(new FindCriteria(typeof(ICalculatorService)));
    
                    Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count);
                    Console.WriteLine();
    
                    // Check to see if endpoints were found, if so then invoke the service.
                    if (findResponse.Endpoints.Count > 0)
                    {
                        InvokeCalculatorService(findResponse.Endpoints[0].Address);
                    }
                }
                catch (TargetInvocationException)
                {
                    Console.WriteLine("This client was unable to connect to and query the proxy. Ensure that the proxy is up and running.");
                }
    
                Console.WriteLine("Press <ENTER> to exit.");
                Console.ReadLine();
            }
    

L'implementazione dell'applicazione client è stata completata. Passare a Procedura: test del proxy di individuazione.

Esempio

Di seguito è riportato il codice completo per questo argomento.

    // GeneratedClient.cs
    //----------------------------------------------------------------
    // Copyright (c) Microsoft Corporation.  All rights reserved.
    //----------------------------------------------------------------
    //------------------------------------------------------------------------------
    // <auto-generated>
    //     This code was generated by a tool.
    //     Runtime Version:2.0.50727.1434
    //
    //     Changes to this file may cause incorrect behavior and will be lost if
    //     the code is regenerated.
    // </auto-generated>
    //------------------------------------------------------------------------------
    
    namespace Microsoft.Samples.Discovery
    {
        [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
        [System.ServiceModel.ServiceContractAttribute(Namespace = "http://Microsoft.Samples.Discovery", ConfigurationName = "ICalculatorService")]
        public interface ICalculatorService
        {
    
            [System.ServiceModel.OperationContractAttribute(ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign, Action = "http://Microsoft.Samples.Discovery/ICalculatorService/Add", ReplyAction = "http://Microsoft.Samples.Discovery/ICalculatorService/AddResponse")]
            double Add(double n1, double n2);
    
            [System.ServiceModel.OperationContractAttribute(ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign, Action = "http://Microsoft.Samples.Discovery/ICalculatorService/Subtract", ReplyAction = "http://Microsoft.Samples.Discovery/ICalculatorService/SubtractResponse")]
            double Subtract(double n1, double n2);
    
            [System.ServiceModel.OperationContractAttribute(ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign, Action = "http://Microsoft.Samples.Discovery/ICalculatorService/Multiply", ReplyAction = "http://Microsoft.Samples.Discovery/ICalculatorService/MultiplyResponse")]
            double Multiply(double n1, double n2);
    
            [System.ServiceModel.OperationContractAttribute(ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign, Action = "http://Microsoft.Samples.Discovery/ICalculatorService/Divide", ReplyAction = "http://Microsoft.Samples.Discovery/ICalculatorService/DivideResponse")]
            double Divide(double n1, double n2);
        }
    
        [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
        public interface ICalculatorServiceChannel : ICalculatorService, System.ServiceModel.IClientChannel
        {
        }
    
        [System.Diagnostics.DebuggerStepThroughAttribute()]
        [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
        public partial class CalculatorServiceClient : System.ServiceModel.ClientBase<ICalculatorService>, ICalculatorService
        {
    
            public CalculatorServiceClient()
            {
            }
    
            public CalculatorServiceClient(string endpointConfigurationName) :
                base(endpointConfigurationName)
            {
            }
    
            public CalculatorServiceClient(string endpointConfigurationName, string remoteAddress) :
                base(endpointConfigurationName, remoteAddress)
            {
            }
    
            public CalculatorServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) :
                base(endpointConfigurationName, remoteAddress)
            {
            }
    
            public CalculatorServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :
                base(binding, remoteAddress)
            {
            }
    
            public double Add(double n1, double n2)
            {
                return base.Channel.Add(n1, n2);
            }
    
            public double Subtract(double n1, double n2)
            {
                return base.Channel.Subtract(n1, n2);
            }
    
            public double Multiply(double n1, double n2)
            {
                return base.Channel.Multiply(n1, n2);
            }
    
            public double Divide(double n1, double n2)
            {
                return base.Channel.Divide(n1, n2);
            }
        }
    }
    // Program.cs
    //----------------------------------------------------------------
    // Copyright (c) Microsoft Corporation.  All rights reserved.
    //----------------------------------------------------------------
    
    using System;
    using System.Reflection;
    using System.ServiceModel;
    using System.ServiceModel.Discovery;
    
    namespace Microsoft.Samples.Discovery
    {
        class Client
        {
            public static void Main()
            {
                // Create a DiscoveryEndpoint that points to the DiscoveryProxy
                Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
                DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress(probeEndpointAddress));
                
                DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint);
    
                Console.WriteLine("Finding ICalculatorService endpoints using the proxy at {0}", probeEndpointAddress);
                Console.WriteLine();
    
                try
                {
                    // Find ICalculatorService endpoints            
                    FindResponse findResponse = discoveryClient.Find(new FindCriteria(typeof(ICalculatorService)));
    
                    Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count);
                    Console.WriteLine();
    
                    // Check to see if endpoints were found, if so then invoke the service.
                    if (findResponse.Endpoints.Count > 0)
                    {
                        InvokeCalculatorService(findResponse.Endpoints[0].Address);
                    }
                }
                catch (TargetInvocationException)
                {
                    Console.WriteLine("This client was unable to connect to and query the proxy. Ensure that the proxy is up and running.");
                }
    
                Console.WriteLine("Press <ENTER> to exit.");
                Console.ReadLine();
            }
    
            static void InvokeCalculatorService(EndpointAddress endpointAddress)
            {
                // Create a client
                CalculatorServiceClient client = new CalculatorServiceClient(new NetTcpBinding(), endpointAddress);
                Console.WriteLine("Invoking CalculatorService at {0}", endpointAddress.Uri);
                Console.WriteLine();
    
                double value1 = 100.00D;
                double value2 = 15.99D;
    
                // Call the Add service operation.
                double result = client.Add(value1, value2);
                Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);
    
                // Call the Subtract service operation.
                result = client.Subtract(value1, value2);
                Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result);
    
                // Call the Multiply service operation.
                result = client.Multiply(value1, value2);
                Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);
    
                // Call the Divide service operation.
                result = client.Divide(value1, value2);
                Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);
                Console.WriteLine();
    
                // Closing the client gracefully closes the connection and cleans up resources
                client.Close();
            }
        }
    }

Vedere anche

Attività

Procedura: implementare un proxy di individuazione
Procedura: implementare un servizio individuabile che esegue la registrazione al proxy di individuazione

Concetti

Panoramica di WCF Discovery