Möglicher gleicher Vertrag, gleiche Bindung, gleiche Adresse, aber unterschiedliche Ports?

Question

Ich habe Handhelds, die über basicHTTPBinding kommunizieren müssen. Ich habe einen Vertrag und alles funktioniert wie angekündigt.

Ich muss es erweitern, um den Wechsel zu einer Testumgebung, Training und natürlich Produktion leicht zu unterstützen. Ich nahm die Hafenroute und dachte, ich könnte verschiedene Endpunkte mit Portunterschieden aufdecken und basierend auf dem Port entscheiden, von welcher Datenbank ich Informationen wollte.

Ich kann nicht scheinen, dass dies funktioniert, und bis jetzt haben keine Informationen nirgendwo gefunden, die anzeigt, dass es getan werden kann. Da Port optional ist, ist es möglicherweise nicht.

Hat jemand so etwas gemacht?

Answer 1

Obwohl Sie mit dem Port nicht tun können, was Sie wollen, können Sie dies mit einem anderen Pfad erreichen. Wie zum Beispiel "/ prod" oder "/ test" an Ihre Basisadresse anhängen. Ich habe ein Beispiel eingefügt, das dies veranschaulicht.

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 
    } 

}