Possible d'avoir le même contrat, la même liaison, la même adresse, mais des ports différents?

Question

J'ai des ordinateurs de poche qui doivent communiquer via basicHTTPBinding. J'ai un contrat et tout fonctionne comme annoncé.

J'ai besoin pour le développer pour soutenir facilement le passage à un environnement de test, de formation et de la production de cours. J'ai pris la route du port, pensant que je pouvais exposer différents points de terminaison avec des différences de port, et en fonction du port, décider de quelle base de données je voulais obtenir des informations.

Je ne peux pas semblent faire ce travail, et jusqu'à présent ont trouvé aucune information qui indique où il peut être fait. Comme le port est facultatif, il se peut que ce ne soit pas le cas.

Quelqu'un a-t-il fait quelque chose comme ça?

Answer 1

Bien que vous ne pouvez pas faire ce que vous voulez avec le port que vous pouvez accomplir cela avec un autre chemin. Comme ajouter "/ prod" ou "/ test" à votre adresse de base. J'ai inclus un exemple qui illustre cela.

using System; 
using System.Collections.Generic; 
using System.Collections.ObjectModel; 
using System.ServiceModel; 
using System.ServiceModel.Description; 

namespace WCFTest 
{ 
    class Program 
    { 
     static void Main() 
     { 
      List<Uri> baseAddresses = new List<Uri> { new Uri("http://localhost:1000/Prod"), new Uri("http://localhost:1000/Test") }; 
      ServiceHost wcfHost = new ServiceHost(typeof(SimpleWCF), new Uri[] {new Uri("http://localhost:1000")}); 

      foreach (ServiceEndpoint endpoint in SimpleWCF.CreateEndpoints(baseAddresses.ToArray())) 
      { 
       wcfHost.AddServiceEndpoint(endpoint); 
      } 

      ServiceMetadataBehavior metadataBehavior = new ServiceMetadataBehavior(); 
      metadataBehavior.HttpGetEnabled = true; 
      wcfHost.Description.Behaviors.Add(metadataBehavior); 

      wcfHost.Open(); 
      Console.ReadLine(); 
      wcfHost.Close(); 
     } 
    } 

    [ServiceContract] 
    public interface ISimpleWCF 
    { 
     [OperationContract] 
     string TestMethod(); 
    } 

    public class SimpleWCF : ISimpleWCF 
    { 
     /// <summary> 
     /// Thread Synchronization Object. 
     /// </summary> 
     private static readonly object _syncRoot = new object(); 

     /// <summary> 
     /// Static Instance of Class. 
     /// </summary> 
     private static volatile SimpleWCF _current; 

     /// <summary> 
     /// Initializes a new instance of the <see cref="WebDataExchange"/> class. 
     /// </summary> 
     public SimpleWCF() 
     { 
      this.Contract = ContractDescription.GetContract(typeof(ISimpleWCF), GetType()); 
     } 

     /// <summary> 
     /// Gets or sets the contract. 
     /// </summary> 
     /// <value>The contract.</value> 
     private ContractDescription Contract { get; set; } 

     /// <summary> 
     /// Gets the current instance of the SimpleWCF Object. 
     /// </summary> 
     /// <value>The current SimpleWCF Object.</value> 
     public static SimpleWCF Current 
     { 
      get 
      { 
       if (_current != null) 
       { 
        return _current; 
       } 

       lock (_syncRoot) 
       { 
        if (_current == null) 
         _current = new SimpleWCF(); 

       } 

       return _current; 
      } 
     } 

     /// <summary> 
     /// Creates an Enpoint Collection. 
     /// </summary> 
     /// <param name="addresses">The addresses.</param> 
     /// <returns>A Collection of ServiceEndpoints.</returns> 
     public static Collection<ServiceEndpoint> CreateEndpoints(Uri[] addresses) 
     { 
      Collection<ServiceEndpoint> endpointCollection = new Collection<ServiceEndpoint>(); 

      foreach (Uri uriAddress in addresses) 
      { 
       EndpointAddress address = new EndpointAddress(uriAddress); 

       BasicHttpSecurityMode securityMode = address.Uri.Scheme == Uri.UriSchemeHttps ? BasicHttpSecurityMode.Transport : BasicHttpSecurityMode.None; 
       BasicHttpBinding endpointBinding = new BasicHttpBinding(securityMode); 

       ServiceEndpoint endpoint = new ServiceEndpoint(Current.Contract, endpointBinding, address); 
       endpoint.ListenUriMode = ListenUriMode.Explicit; 
       endpointCollection.Add(endpoint); 
      } 

      return endpointCollection; 
     } 

     #region ISimpleWCF Members 

     string ISimpleWCF.TestMethod() 
     { 
      if (OperationContext.Current.Channel.LocalAddress.Uri.AbsoluteUri.EndsWith("Prod")) 
       return "Hello Prod!"; 
      else return "Hello Test!"; 
     } 

     #endregion 
    } 

}