System.ServiceModel.Diagnostics.CallbackException: 
A user callback threw an exception.  
Check the exception stack and inner exception to determine the callback that failed. 
---> System.NullReferenceException: Object reference not set to 
     an instance of an object.
   at System.ServiceModel.Channels.DatagramChannelDemuxer`2.
      OnListenerClosed(Object source, EventArgs args)
   at System.ServiceModel.Channels.CommunicationObject.OnClosed()
   --- End of inner exception stack trace ---
   at System.ServiceModel.Channels.CommunicationObject.OnClosed()
   at System.ServiceModel.Channels.CommunicationObject.Abort()
   at System.ServiceModel.Channels.ChannelListenerBase.OnAbort()
   at System.ServiceModel.Channels.SecurityChannelListener`1.OnAbort()
   at System.ServiceModel.Channels.CommunicationObject.Abort()
   at System.ServiceModel.Channels.ChannelListenerBase.OnAbort()
   at System.ServiceModel.Channels.CommunicationObject.Abort()
   at System.ServiceModel.Dispatcher.ChannelDispatcher.OnAbort()
   at System.ServiceModel.Channels.CommunicationObject.Abort()
   at System.ServiceModel.ServiceHostBase.OnAbort()
   at System.ServiceModel.Channels.CommunicationObject.Abort()
   at System.ServiceModel.Channels.CommunicationObject.Close(
      TimeSpan timeout)
   at System.ServiceModel.Channels.CommunicationObject.Close()
   at System.ServiceModel.Channels.CommunicationObject.Dispose()
   at Program.Main(String[] args) in 
      C:\work\HelloService\Program.cs:line 24
    	

//hello.cs - simple WCF Web service that listens on HTTP
using System;
using System.ServiceModel;

[ServiceContract(Namespace = "http://example.org")]
public interface IHello {
    [OperationContract]
    void SayHello();
}

public class Hello : IHello {
    public void SayHello() {
        Console.WriteLine("Hello");
    }
}

class ConsoleHost {
    static void Main(string[] args) {
        try {
            using (ServiceHost host = new ServiceHost(typeof(Hello), 
                    new Uri("http://localhost:8080/MyServices/"))) {
                host.Open();

                Console.WriteLine(
                    "Service is listening, press any key to quit.");
                Console.ReadKey();
            }
        }
        catch (Exception x) {
            Console.WriteLine(x);
        }
    }
}

<!--app.config-->
<configuration>
  <system.serviceModel>
    <services>
      <service name="Hello">
        <endpoint address="Hello"
                  binding="wsHttpBinding"
                  contract="IHello"/>
      </service>
    </services>
  </system.serviceModel>
</configuration>

using System;
using System.Xml;
using System.Security.Principal;
using System.Runtime.InteropServices;

public class ReserveHttpNamespace {
    static void Main(string[] args) {
        if (args.Length != 2) {
            Console.WriteLine(
                "Usage: reserveHttpNamespace " +
                "prefix account");
            return;
        }
        try {
            ModifyReservation(args[0], args[1], false);
            Console.WriteLine("Success!");
        }
        catch (Exception x) {
            Console.WriteLine(x.Message);
        }
    }

    static void ModifyReservation(
            string urlPrefix, string accountName,
            bool removeReservation) {
        string sddl = createSddl(accountName);
        HTTP_SERVICE_CONFIG_URLACL_SET configInfo;
        configInfo.Key.UrlPrefix = urlPrefix;
        configInfo.Param.Sddl = sddl;
        HTTPAPI_VERSION httpApiVersion =
            new HTTPAPI_VERSION(1, 0);
        int errorCode = HttpInitialize(httpApiVersion,
            HTTP_INITIALIZE_CONFIG, IntPtr.Zero);
        if (0 != errorCode) 
            throw getException("HttpInitialize", errorCode);
        try {
            // do our best to delete any existing ACL
            errorCode = HttpDeleteServiceConfigurationAcl(
                IntPtr.Zero, HttpServiceConfigUrlAclInfo,
                ref configInfo, Marshal.SizeOf(
                    typeof(HTTP_SERVICE_CONFIG_URLACL_SET)),
                IntPtr.Zero);
            if (removeReservation) {
                if (0 != errorCode) throw getException(
                    "HttpDeleteServiceConfigurationAcl",
                    errorCode);
                return;
            }
            errorCode = HttpSetServiceConfigurationAcl(
                IntPtr.Zero, HttpServiceConfigUrlAclInfo,
                ref configInfo, Marshal.SizeOf(
                    typeof(HTTP_SERVICE_CONFIG_URLACL_SET)),
                IntPtr.Zero);
            if (0 != errorCode) throw getException(
                "HttpSetServiceConfigurationAcl", errorCode);
        }
        finally {
            errorCode = HttpTerminate(
                HTTP_INITIALIZE_CONFIG, IntPtr.Zero);
            if (0 != errorCode) throw getException(
                "HttpTerminate",errorCode);
        }
    }

    static Exception getException(string fcn, int errorCode) {
        return new Exception(
            string.Format("{0} failed: {1}",
            fcn, getWin32ErrorMessage(errorCode)));
    }

    static string createSddl(string account) {
        string sid = new NTAccount(account).Translate(
            typeof(SecurityIdentifier)).ToString();
        // DACL that allows generic execute for the user
        // specified by account.
        // See help for HTTP_SERVICE_CONFIG_URLACL_PARAM
        // for details on what this means.
        return string.Format("D:(A;;GX;;;{0})", sid);
    }

    static string getWin32ErrorMessage(int errorCode) {
        return Marshal.GetExceptionForHR(HRESULT_FROM_WIN32(errorCode));
    }
    static int HRESULT_FROM_WIN32(int errorCode) {
        if (errorCode <= 0) return errorCode;
        return (int)((0x0000FFFFU & ((uint)errorCode)) | (7U << 16) |
            0x80000000U);
    }

    // P/Invoke stubs from http.h
    const int HttpServiceConfigUrlAclInfo = 2;
    const int HTTP_INITIALIZE_CONFIG = 2;
    [StructLayout(LayoutKind.Sequential)]
    struct HTTPAPI_VERSION {
        public HTTPAPI_VERSION(short maj, short min) {
            Major = maj; Minor = min;
        }
        short Major;
        short Minor;
    }
    [StructLayout(LayoutKind.Sequential)]
    struct HTTP_SERVICE_CONFIG_URLACL_KEY {
        [MarshalAs(UnmanagedType.LPWStr)]
        public string UrlPrefix;
    }
    [StructLayout(LayoutKind.Sequential)]
    struct HTTP_SERVICE_CONFIG_URLACL_PARAM {
        [MarshalAs(UnmanagedType.LPWStr)]
        public string Sddl;
    }
    [StructLayout(LayoutKind.Sequential)]
    struct HTTP_SERVICE_CONFIG_URLACL_SET {
        public HTTP_SERVICE_CONFIG_URLACL_KEY Key;
        public HTTP_SERVICE_CONFIG_URLACL_PARAM Param;
    }
    [DllImport("httpapi.dll", ExactSpelling = true,
            EntryPoint = "HttpSetServiceConfiguration")]
    static extern int HttpSetServiceConfigurationAcl(
        IntPtr mustBeZero, int configID,
        [In] ref HTTP_SERVICE_CONFIG_URLACL_SET configInfo,
        int configInfoLength, IntPtr mustBeZero2);
    [DllImport("httpapi.dll", ExactSpelling = true,
            EntryPoint = "HttpDeleteServiceConfiguration")]
    static extern int HttpDeleteServiceConfigurationAcl(
        IntPtr mustBeZero, int configID,
        [In] ref HTTP_SERVICE_CONFIG_URLACL_SET configInfo,
        int configInfoLength, IntPtr mustBeZero2);
    [DllImport("httpapi.dll")]
    static extern int HttpInitialize(
        HTTPAPI_VERSION version,
        int flags, IntPtr mustBeZero);
    [DllImport("httpapi.dll")]
    static extern int HttpTerminate(int flags,
        IntPtr mustBeZero);
}

public static List<byte[]> SplitSecret(byte[] secret, int count) {
    if (null == secret || 0 == secret.Length) 
        throw new ArgumentException("Non-empty value required",
        "secret");
    if (count < 2) 
        throw new ArgumentException("Must be greater than one", "count");

    RNGCryptoServiceProvider random = new RNGCryptoServiceProvider();

    // Get N-1 new secrets.
    List<byte[]> newSecrets = new List<byte[]>(count);
    for (int i = 0; i < count - 1; ++i) {
        byte[] newSecret = new byte[secret.Length];
        random.GetBytes(newSecret);
        newSecrets.Add(newSecret);
    }

    // XOR all secrets into the existing one to get the final secret.
    byte[] finalSecret = (byte[])secret.Clone();
    foreach (byte[] newSecret in newSecrets) {
        for (int i = 0; i < finalSecret.Length; ++i) {
            finalSecret[i] ^= newSecret[i];
        }
    }
    newSecrets.Add(finalSecret);

    return newSecrets;
}

public static byte[] JoinSecret(List<byte[]> splitSecrets) {
    if (null == splitSecrets) throw new ArgumentNullException();

    byte[] secret = null;
    foreach (byte[] splitSecret in splitSecrets) {
        if (null == splitSecret) throw new ArgumentNullException();
        if (null == secret) {
            secret = (byte[])splitSecret.Clone();
            continue;
        }
        if (splitSecret.Length != secret.Length) 
            throw new ArgumentException(
                "All secrets must be of the same length");

        // XOR all the split secrets together to get the original secret.
        for (int i = 0; i < secret.Length; ++i) {
            secret[i] ^= splitSecret[i];
        }
    }
    return secret;
}