WCF BasicHttpBinding Programmatically

// see http://stackoverflow.com/questions/15050641/
using System;
using System.IO;
using System.Net;
using System.Security.Cryptography.X509Certificates;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Security;
using System.ServiceModel.Web;
using System.Text;

namespace ServerConsole
{
    internal class Program
    {
        public enum Server
        {
            None,
            Basic,
            Secure
        }

        private static readonly Uri UriBase = new Uri("http://localhost:8080/");
        private static readonly Uri UriBaseService = new Uri("http://localhost:8080/Basic");

        private static readonly Uri UriSecure = new Uri("https://localhost:8081/");
        private static readonly Uri UriSecureService = new Uri("https://localhost:8081/Secure");

        private static ServiceHost _serviceHost;
        private static ServiceHost _serviceHostSecure;

        private static void Main(string[] args)
        {
            ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;

            Logger.Log(Server.Basic, "Start");
            BasicHTTPServer();

            Logger.Log(Server.Secure, "Start");
            SecureHTTPServer();

            Console.ReadKey();

            _serviceHost.Close();
        }

        private static void SecureHTTPServer()
        {
            var binding = new BasicHttpBinding();
            binding.Name = "binding2";
            binding.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
            binding.Security.Mode = BasicHttpSecurityMode.Transport;
            binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;

            // Create a ServiceHost for the CalculatorService type and provide the base address.
            _serviceHostSecure = new ServiceHost(typeof (ServiceBasic), UriSecure);
            _serviceHostSecure.Credentials.ServiceCertificate.Certificate = GetCertificate();
                //load a certificate from file
            _serviceHostSecure.Credentials.ClientCertificate.Authentication.CertificateValidationMode =
                X509CertificateValidationMode.None;

            _serviceHostSecure.AddServiceEndpoint(typeof (IServiceBasic), binding, UriSecureService);
            var webHttpBinding = new WebHttpBinding(WebHttpSecurityMode.Transport);
            webHttpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Certificate;

            _serviceHostSecure.AddServiceEndpoint(typeof (IPolicyRetriever), webHttpBinding, "")
                              .Behaviors.Add(new WebHttpBehavior());
            var smb = new ServiceMetadataBehavior {HttpsGetEnabled = true, HttpsGetUrl = UriSecure};
            _serviceHostSecure.Description.Behaviors.Add(smb);

            // Open the ServiceHostBase to create listeners and start listening for messages.
            _serviceHostSecure.Open();
            Logger.Log(Server.Basic, string.Format("Open at {0} Service: {1}", UriSecure, UriSecureService));
        }

        private static X509Certificate2 GetCertificate()
        {
            var x509Certificate2 = new X509Certificate2("Server.pfx");
            Logger.Log(Server.Secure,
                       string.Format("Get X509Certificate2:{0}{1}", Environment.NewLine, x509Certificate2));
            return x509Certificate2;
        }

        private static void BasicHTTPServer()
        {
            var binding = new BasicHttpBinding();
            binding.Name = "binding1";
            binding.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
            binding.Security.Mode = BasicHttpSecurityMode.None;

            // Create a ServiceHost for the CalculatorService type and provide the base address.
            _serviceHost = new ServiceHost(typeof (ServiceBasic), UriBase);

            _serviceHost.AddServiceEndpoint(typeof (IServiceBasic), binding, UriBaseService);
            _serviceHost.AddServiceEndpoint(typeof (IPolicyRetriever), new WebHttpBinding(), "")
                        .Behaviors.Add(new WebHttpBehavior());
            var smb = new ServiceMetadataBehavior {HttpGetEnabled = true, HttpGetUrl = UriBase};
            _serviceHost.Description.Behaviors.Add(smb);

            // Open the ServiceHostBase to create listeners and start listening for messages.
            _serviceHost.Open();
            Logger.Log(Server.Basic, string.Format("Open at {0} Service: {1}", UriBase, UriBaseService));
        }
    }

    //[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
    internal class ServiceBasic : IServiceBasic, IPolicyRetriever
    {
        public Stream GetSilverlightPolicy()
        {
            Logger.Log(Program.Server.None, "PolicyRetriever - GetSilverlightPolicy");
            string result = @"<?xml version=""1.0"" encoding=""utf-8""?>
<access-policy>
    <cross-domain-access>
        <policy>
            <allow-from http-request-headers=""*"">
                <domain uri=""*""/>
            </allow-from>
            <grant-to>
                <resource path=""/"" include-subpaths=""true""/>
            </grant-to>
        </policy>
    </cross-domain-access>
</access-policy>";
            return StringToStream(result);
        }

        public Stream GetFlashPolicy()
        {
            Logger.Log(Program.Server.None, "PolicyRetriever - GetFlashPolicy");
            string result = @"<?xml version=""1.0""?>
<!DOCTYPE cross-domain-policy SYSTEM ""http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd"">
<cross-domain-policy>
    <allow-access-from domain=""*"" />
</cross-domain-policy>";
            return StringToStream(result);
        }

        public string TestMethod(string testMessage)
        {
            Logger.Log(Program.Server.Basic, "TestMethod called with: " + testMessage);

            return testMessage;
        }

        private Stream StringToStream(string result)
        {
            WebOperationContext.Current.OutgoingResponse.ContentType = "application/xml";
            return new MemoryStream(Encoding.UTF8.GetBytes(result));
        }
    }

    [ServiceContract]
    internal interface IServiceBasic
    {
        [OperationContract]
        string TestMethod(string testMessage);
    }

    [ServiceContract]
    public interface IPolicyRetriever
    {
        [OperationContract, WebGet(UriTemplate = "/clientaccesspolicy.xml")]
        Stream GetSilverlightPolicy();

        [OperationContract, WebGet(UriTemplate = "/crossdomain.xml")]
        Stream GetFlashPolicy();
    }
}