Extremos estándar

Artículo
02/27/2011

Los extremos se definen mediante la especificación de una dirección, un enlace y un contrato. Otros parámetros que se pueden establecer en un extremo incluyen la configuración del comportamiento, los encabezados y los URI de escucha. Para ciertos tipos de extremos, estos valores no cambian. Por ejemplo, los extremos de intercambio de metadatos siempre utilizan el contrato IMetadataExchange. Otros extremos, como WebHttpEndpoint, siempre requieren un comportamiento de extremo especificado. La utilidad de un extremo se puede mejorar teniendo extremos con valores predeterminado para las propiedades de extremo utilizadas normalmente. Los extremos estándar permiten a un desarrollador definir un extremo que tenga los valores predeterminados o en el que una o más propiedades del extremo no cambien. Estos extremos le permiten utilizar un extremo de este tipo sin tener que especificar información de tipo estático. Los extremos estándar se pueden usar para extremos de la aplicación y de la infraestructura.

Extremos de infraestructura

Un servicio puede exponer extremos con algunas de las propiedades no implementadas de forma explícita por el autor del servicio. Por ejemplo, el extremo del intercambio de metadatos expone el contrato IMetadataExchange pero, como autor del servicio, no implementa esa interfaz, pues la implementa WCF. Estos extremos de infraestructura tienen valores predeterminados para una o más propiedades de extremo, algunos de los cuales pueden ser inalterables. La propiedad Contract del extremo del intercambio de metadatos debe ser IMetadataExchange, mientras que el desarrollador puede proporcionar otras propiedades, como el enlace. Los extremos de la infraestructura se identifican estableciendo la propiedad IsSystemEndpoint en true.

Extremos de la aplicación

Los desarrolladores de la aplicación pueden definir sus propios extremos estándar que especifican los valores predeterminados para la dirección, el enlace o el contrato. Defina un extremo estándar derivando una clase de ServiceEndpoint y estableciendo las propiedades de extremo adecuadas. Puede proporcionar valores predeterminados a propiedades que se pueden cambiar. Otras propiedades tendrán valores estáticos que no podrán cambiar. En el siguiente ejemplo, se muestra cómo implementar un extremo estándar.

public class CustomEndpoint : ServiceEndpoint
    {
        public CustomEndpoint()
            : this(string.Empty)
        {
        }

        public CustomEndpoint(string address)
            : this(address, ContractDescription.GetContract(typeof(ICalculator)))
        {
        }

        // Create the custom endpoint with a fixed binding
        public CustomEndpoint(string address, ContractDescription contract)
            : base(contract)
        {
            this.Binding = new BasicHttpBinding();
            this.IsSystemEndpoint = false;
        }

        // Definition of the additional property of this endpoint
        public bool Property
        {
            get;
            set;
        }
    }

Para utilizar un extremo personalizado definido por el usuario en un archivo de configuración, debe derivar una clase de StandardEndpointElement, derivar una clase de StandardEndpointCollectionElement y registrar el nuevo extremo estándar en la sección de extensiones en app.config o en machine.config. La clase StandardEndpointElement proporciona el soporte técnico de configuración para el extremo estándar, tal y como se muestra en el siguiente ejemplo.

public class CustomEndpointElement : StandardEndpointElement
    {
        // Definition of the additional property for the standard endpoint element
        public bool Property
        {
            get { return (bool)base["property"]; }
            set { base["property"] = value; }
        }

        // The additional property needs to be added to the properties of the standard endpoint element
        protected override ConfigurationPropertyCollection Properties
        {
            get
            {
                ConfigurationPropertyCollection properties = base.Properties;
                properties.Add(new ConfigurationProperty("property", typeof(bool), false, ConfigurationPropertyOptions.None));
                return properties;
            }
        }

        // Return the type of this standard endpoint
        protected override Type EndpointType
        {
            get { return typeof(CustomEndpoint); }
        }

        // Create the custom service endpoint
        protected override ServiceEndpoint CreateServiceEndpoint(ContractDescription contract)
        {
            return new CustomEndpoint();
        }

        // Read the value given to the property in config and save it
        protected override void OnApplyConfiguration(ServiceEndpoint endpoint, ServiceEndpointElement serviceEndpointElement)
        {
            CustomEndpoint customEndpoint = (CustomEndpoint)endpoint;
            customEndpoint.Property = this.Property;
        }

        // Read the value given to the property in config and save it
        protected override void OnApplyConfiguration(ServiceEndpoint endpoint, ChannelEndpointElement channelEndpointElement)
        {
            CustomEndpoint customEndpoint = (CustomEndpoint)endpoint;
            customEndpoint.Property = this.Property;
        }

        // No validation in this sample
        protected override void OnInitializeAndValidate(ServiceEndpointElement serviceEndpointElement)
        {
        }

        // No validation in this sample
        protected override void OnInitializeAndValidate(ChannelEndpointElement channelEndpointElement)
        {
        }
    }

La clase StandardEndpointCollectionElement proporciona el tipo de apoyo para la recopilación que aparece en la sección <standardEndpoints> de la configuración correspondiente al extremo estándar. En el siguiente ejemplo, se muestra cómo implementar esta clase.

public class CustomEndpointCollectionElement : StandardEndpointCollectionElement<CustomEndpoint, CustomEndpointElement>
    {
         // ...

    }

En el siguiente ejemplo, se muestra cómo registrar un extremo estándar en la sección de extensiones.

<extensions>
      <standardEndpointExtensions>
        <add
          name="customStandardEndpoint"
          type="CustomEndpointCollectionElement, Example.dll,
                Version=1.0.0.0, Culture=neutral, PublicKeyToken=ffffffffffffffff"/>

Configurar un extremo estándar

Los extremos estándar se pueden agregar en código o en configuración. Para agregar un extremo estándar en código, basta con crear instancias del tipo de extremo estándar adecuado y agregarlo al host del servicio, tal y como se muestra en el siguiente ejemplo:

serviceHost.AddServiceEndpoint(new CustomEndpoint());

Para agregar un extremo estándar en configuración, agregue un elemento <endpoint> al elemento <service> y cualquier configuración necesitada en el elemento <standardEndpoints>. En el siguiente ejemplo, se muestra cómo agregar UdpDiscoveryEndpoint, uno de los extremos estándar que se distribuye con .NET Framework 4.

<services>
  <service>
    <endpoint isSystemEndpoint=”true” kind=”udpDiscoveryEndpoint” />
  </service>
</services>
<standardEndpoints>  
  <udpDiscoveryEndpoint>
     <standardEndpoint multicastAddress="soap.udp://239.255.255.250:3702" /> 
  </udpDiscoveryEndpoint>
</ standardEndpoints >

El tipo de extremo estándar se especifica mediante el atributo de clase en el elemento <endpoint>. El extremo se configura dentro del elemento <standardEndpoints>. En el ejemplo anterior, se agrega y se configura un extremo de UdpDiscoveryEndpoint. El elemento <udpDiscoveryEndpoint> contiene un <standardEndpoint> que establece la propiedad MulticastAddress de UdpDiscoveryEndpoint.