WCF - Possible to have same contract, same binding, same address, but different ports?

Question

I have handhelds that need to communicate via basicHTTPBinding. I have a contract and everything works as advertised.

I need to expand it to easily support changing to a test environment, training and of course production. I took the port route, thinking I could expose different endpoints with port differences, and based on the port, decide which database I wanted info from.

I cant seem to make this work, and so far have found no information anywhere that indicates it can be done. Since port is optional, it may not be.

Anyone done anything like this?

Answer 1

Although you can't do what you want with the port you can accomplish this with a different path. Such as appending "/prod" or "/test" to your base address. I've included an example that illustrates this.

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
    }

}