EndpointAddress Class

Definition

Namespace:

System.ServiceModel

Assembly:

System.ServiceModel.Primitives.dll

Package:

System.ServiceModel.Primitives v8.1.0

Source:

EndpointAddress.cs

Provides a unique network address that a client uses to communicate with a service endpoint.

public ref class EndpointAddress

public class EndpointAddress

type EndpointAddress = class

Public Class EndpointAddress

Inheritance

Object

EndpointAddress

Examples

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

Remarks

An endpoint address uniquely identifies the endpoint for a service.

The endpoint address belongs to the service endpoint, which also contains the binding, contract and behaviors for the endpoint.

The EndpointAddress contains a URI and address properties that include an identity, WSDL elements, and a collection of optional headers. The optional headers are used to provide additional, more detailed addressing information to identify or interact with the endpoint. For example, they can be used to indicate which instance of a service is to be used to process an incoming message from a particular user when multiple instances are available.

The endpoint address for a service can be specified either imperatively using code or declaratively through configuration. Defining endpoints in code is usually not practical because the bindings and addresses for a deployed service are typically different from those used while the service is being developed. It is more practical to define service endpoints using configuration.

EndpointAddress does not implement the ISerializable interface and so is not serializable. For an endpoint to be exposed as part of a service contract it must be serializable and it must also be compliant with the Web Service Addressing (WS-Addressing) protocol. Serializable endpoints that are compliant with version 1.0 and the August 2004 version of WS-Addressing are provided, respectively, by the EndpointAddress10 and EndpointAddressAugust2004 classes.

Constructors

EndpointAddress(String)	Initializes a new instance of the EndpointAddress class with a specified URI string.
EndpointAddress(Uri, AddressHeader[])	Initializes a new instance of the EndpointAddress class with a specified URI and headers.
EndpointAddress(Uri, EndpointIdentity, AddressHeader[])	Initializes a new instance of the EndpointAddress class with a specified URI, identity, and headers.

Properties

AnonymousUri	Gets a version-neutral representation of the anonymous URI.
Headers	Gets the collection of address headers for the endpoints that the builder can create.
Identity	Gets the identity for the endpoint used to authenticate it.
IsAnonymous	Gets a value that indicates whether the endpoint is anonymous.
IsNone	Gets a value that indicates whether the URI for the endpoint is the NoneUri.
NoneUri	Gets a version-neutral URI used for the address of an endpoint to which a message must not be sent.
Uri	Gets the URI for the endpoint.

Methods

ApplyTo(Message)	Assigns the URI and properties of the endpoint address to the values of the headers of a specified message.
Equals(Object)	Returns a value that indicates whether a specified object is equivalent to the current endpoint address.
GetHashCode()	Provides a unique hash code for the current endpoint address.
GetType()	Gets the Type of the current instance. (Inherited from Object)
MemberwiseClone()	Creates a shallow copy of the current Object. (Inherited from Object)
ReadFrom(AddressingVersion, XmlDictionaryReader)	Reads an endpoint address for a specified address version from a specified XML dictionary reader.
ToString()	Returns a canonical string representation of the URI that is contained in the endpoint address.
WriteContentsTo(AddressingVersion, XmlDictionaryWriter)	Saves all the child nodes of the node to the XML dictionary writer specified.

Operators

Equality(EndpointAddress, EndpointAddress)	Returns a value that indicates whether specified endpoint addresses are not equivalent.
Inequality(EndpointAddress, EndpointAddress)	Returns a value that indicates whether specified endpoint addresses are not equivalent.