EndpointAddress Classe

Référence

Définition

Espace de noms:: System.ServiceModel

Assembly:: System.ServiceModel.Primitives.dll

Assembly:: System.ServiceModel.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit une adresse réseau unique permettant à un client de communiquer avec un point de terminaison de service.

public ref class EndpointAddress

public class EndpointAddress

type EndpointAddress = class

Public Class EndpointAddress

Héritage: Object
EndpointAddress

Exemples

using System;
using System.Configuration;
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;

using System.Text;

namespace Microsoft.WCF.Documentation
{
  class HostApplication
  {

    static void Main()
    {
      HostApplication app = new HostApplication();
      app.Run();
    }

    private void Run()
    {

            // Get base address from app settings in configuration
            Uri baseAddress = new Uri(ConfigurationManager.AppSettings["baseAddress"]);

            //Create new address headers for special services and add them to an array
            AddressHeader addressHeader1 = AddressHeader.CreateAddressHeader(
                "specialservice1", "http://localhost:8000/service", 1);
            AddressHeader addressHeader2 = AddressHeader.CreateAddressHeader(
                "specialservice2", "http://localhost:8000/service", 2);

            // Enumerate address headers and their properties from the array.
            AddressHeader[] addressHeaders = new AddressHeader[2] { addressHeader1, addressHeader2 };
            foreach (AddressHeader addressHeader in addressHeaders)
            {
                Console.WriteLine("AddressHeader - namespace:\t\t{0}", addressHeader.Namespace);
                Console.WriteLine("              - name:\t\t\t{0}", addressHeader.Name);
                Console.WriteLine("              - value:\t\t\t{0}", addressHeader.GetValue<int>());
                Console.WriteLine("              - type:\t\t\t{0}", addressHeader.GetType());
                Console.WriteLine("              - hashcode:\t\t{0}", addressHeader.GetHashCode());
                Console.WriteLine("              - equals addressHeader1:\t{0}", addressHeader.Equals(addressHeader1));
             //   Console.WriteLine("              - Is SOAP1.1 supported:\t{0}", addressHeader.ToMessageHeader().IsMessageVersionSupported(MessageVersion.WSAddressingSoap10));
                Console.WriteLine();
            }
            Console.WriteLine();

            //Add the array of address headers to an endpoint address
            EndpointAddress endpointAddress = new EndpointAddress(
                        new Uri("http://localhost:8003/servicemodelsamples/service"), addressHeaders);

            //Create a "special" service endpoint that uses the endpointAddress.
            string WSHttpBindingName = "Binding1";
            ServiceEndpoint specialServiceEndpoint = new ServiceEndpoint(
                ContractDescription.GetContract(typeof(CalculatorService)), new WSHttpBinding(WSHttpBindingName), endpointAddress
                );

            // Create a ServiceHost for the CalculatorService type that uses the base address.
            ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);

            //Add the specialServiceEndpoint to the serviceHost.
            serviceHost.Description.Endpoints.Add(specialServiceEndpoint);

            // Enumerate the service endpoints and some of their properties from the serviceHost.
            Console.WriteLine("Service endpoints:");
            ServiceDescription desc = serviceHost.Description;
            foreach (ServiceEndpoint endpoint in desc.Endpoints)
            {
                Console.WriteLine("Endpoint - address:  {0}", endpoint.Address);
                Console.WriteLine("         - binding name:\t\t{0}", endpoint.Binding.Name);
                // Console.WriteLine("         - binding name:\t\t{0}", endpoint.);
                Console.WriteLine("         - contract name:\t\t{0}", endpoint.Contract.Name);
                Console.WriteLine("         - contains addressHeader1:\t{0}", endpoint.Address.Headers.Contains(addressHeader1));
                Console.WriteLine("         - count of address headers:\t{0}", endpoint.Address.Headers.Count);
                Console.WriteLine();
            }

            Console.WriteLine();

            // Open the ServiceHostBase to create listeners and start listening for messages.
            serviceHost.Open();

            // The service can now be accessed.
            Console.WriteLine("The service is ready.");
            Console.WriteLine("Press <ENTER> to terminate service.");
            Console.WriteLine();
            Console.ReadLine();

            // Close the ServiceHostBase to shutdown the service.
            serviceHost.Close();
        }
    }
  }

Remarques

Une adresse de point de terminaison identifie de manière unique le point de terminaison d'un service.

L'adresse de point de terminaison appartient au point de terminaison de service, lequel contient également la liaison, le contrat et les comportements pour le point de terminaison.

Le EndpointAddress contient un URI et des propriétés d'adresse qui incluent une identité, des éléments WSDL et une collection d'en-têtes facultatifs. Les en-têtes facultatifs sont utilisés pour fournir des informations d'adressage supplémentaires plus détaillées pour identifier le point de terminaison ou interagir avec lui. Par exemple, ils peuvent être utilisés pour indiquer quelle instance d'un service doit être utilisée pour traiter un message entrant d'un utilisateur particulier lorsque plusieurs instances sont disponibles.

L'adresse du point de terminaison pour un service peut être spécifiée de manière impérative en utilisant le code ou de façon déclarative par la configuration. La définition de points de terminaison dans le code est généralement peu pratique car les liaisons et les adresses pour un service déployé sont en général différentes de celles utilisées au cours du développement du service. Il est plus pratique de définir des points de terminaison de service à l’aide de la configuration.

EndpointAddress n’implémente pas l’interface ISerializable et n’est donc pas sérialisable. Pour qu'un point de terminaison soit exposé dans le cadre d'un contrat de service, il doit être sérialisable et être également conforme au protocole d'adressage (WS-Addressing) de service Web. Les points de terminaison sérialisables qui sont conformes avec la version 1.0 et la version d'août 2004 de WS-Addressing sont fournis, respectivement, par les classes EndpointAddress10 et EndpointAddressAugust2004.

Constructeurs

EndpointAddress(String)	Initialise une nouvelle instance de la classe EndpointAddress avec une chaîne URI spécifiée.
EndpointAddress(Uri, AddressHeader[])	Initialise une nouvelle instance de la classe EndpointAddress avec un URI et des en-têtes spécifiés.
EndpointAddress(Uri, EndpointIdentity, AddressHeader[])	Initialise une nouvelle instance de la classe EndpointAddress avec un URI, une identité et des en-têtes spécifiés.
EndpointAddress(Uri, EndpointIdentity, AddressHeaderCollection)	Initialise une nouvelle instance de la classe EndpointAddress avec un URI, une identité et une collection d’en-têtes spécifiés.
EndpointAddress(Uri, EndpointIdentity, AddressHeaderCollection, XmlDictionaryReader, XmlDictionaryReader)	Initialise une nouvelle instance de la classe EndpointAddress avec un URI, une identité, une collection d'en-têtes, et des lecteurs de métadonnées et d'extension spécifiés.

Propriétés

AnonymousUri	Obtient une représentation de version indépendante de l'URI anonyme.
Headers	Obtient la collection d’en-têtes d’adresse des points de terminaison que le générateur peut créer.
Identity	Obtient l'identité pour le point de terminaison utilisé pour l'authentifier.
IsAnonymous	Obtient une valeur qui indique si le point de terminaison est anonyme.
IsNone	Obtient une valeur qui indique si l'URI pour le point de terminaison est la propriété NoneUri.
NoneUri	Obtient un URI de version indépendante utilisé pour l'adresse d'un point de terminaison auquel un message ne doit pas être envoyé.
Uri	Obtient l'URI pour le point de terminaison.

Méthodes

ApplyTo(Message)	Assigne l'URI et les propriétés de l'adresse de point de terminaison aux valeurs des en-têtes d'un message spécifié.
Equals(Object)	Retourne une valeur qui indique si un objet spécifié est équivalent à l'adresse actuelle du point de terminaison.
GetHashCode()	Fournit un code de hachage unique pour l'adresse du point de terminaison actuel.
GetReaderAtExtensions()	Obtient le lecteur de dictionnaire XML qui fournit l’accès aux extensions.
GetReaderAtMetadata()	Obtient le lecteur de dictionnaire XML qui fournit l'accès aux métadonnées pour un point de terminaison.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ReadFrom(AddressingVersion, XmlDictionaryReader)	Lit une adresse de point de terminaison pour une version d'adresse spécifiée à partir d'un lecteur de dictionnaire XML spécifié.
ReadFrom(AddressingVersion, XmlDictionaryReader, XmlDictionaryString, XmlDictionaryString)	Lit une adresse de point de terminaison pour une version d'adresse spécifiée avec un nom qualifié spécifié à partir d'un lecteur de dictionnaire XML spécifié.
ReadFrom(AddressingVersion, XmlReader)	Lit une adresse de point de terminaison pour une version d'adresse spécifiée à partir d'un lecteur XML spécifié.
ReadFrom(AddressingVersion, XmlReader, String, String)	Lit une adresse de point de terminaison pour une version d'adresse spécifiée avec un nom qualifié spécifié à partir d'un lecteur XML spécifié.
ReadFrom(XmlDictionaryReader)	Lit une adresse de point de terminaison à partir d'un lecteur de dictionnaire XML spécifié.
ReadFrom(XmlDictionaryReader, XmlDictionaryString, XmlDictionaryString)	Lit une adresse de point de terminaison avec un nom qualifié spécifié à partir d'un lecteur de dictionnaire XML spécifié.
ToString()	Retourne une représentation sous forme de chaîne canonique de l'URI contenu dans l'adresse de point de terminaison.
WriteContentsTo(AddressingVersion, XmlDictionaryWriter)	Enregistre tous les nœuds enfants du nœud sur le writer de dictionnaire XML spécifié.
WriteContentsTo(AddressingVersion, XmlWriter)	Enregistre tous les nœuds enfants du nœud sur le writer XML spécifié.
WriteTo(AddressingVersion, XmlDictionaryWriter)	Enregistre l'adresse de point de terminaison actuelle d'une version spécifiée sur un writer de dictionnaire XML spécifié.
WriteTo(AddressingVersion, XmlDictionaryWriter, XmlDictionaryString, XmlDictionaryString)	Enregistre l'adresse de point de terminaison actuelle d'une version spécifiée sur un writer de dictionnaire XML avec un espace de noms et un nom local spécifiés.
WriteTo(AddressingVersion, XmlWriter)	Enregistre l'adresse de point de terminaison actuelle d'une version spécifiée sur un writer XML spécifié.
WriteTo(AddressingVersion, XmlWriter, String, String)	Enregistre l'adresse de point de terminaison actuelle d'une version spécifiée sur un writer XML avec un espace de noms et un nom local spécifiés.

Opérateurs

Equality(EndpointAddress, EndpointAddress)	Retourne une valeur qui indique si des adresses de point de terminaison spécifiées ne sont pas équivalentes.
Inequality(EndpointAddress, EndpointAddress)	Retourne une valeur qui indique si des adresses de point de terminaison spécifiées ne sont pas équivalentes.

S’applique à