Dan Rigsby – Coding Up Style

On the MSDN Forums for WCF recently, an enhancement request was proposed to add an event to the ServiceHost class that is fired when a new instance of the service is created.  The proposed event would look something like this:

 

ServiceHost host = new ServiceHost(typeof(MyService));
host.Open();
host.InstanceCreated += new EventHandler<InstanceEventArgs>(host_InstanceCreated);

 

It was decided that this may not be the best enhancement request since this could be done today with the extension mechanisms built into WCF.  The usefulness of the event is also dependent on the type of InstanceContextMode used:

public class InstanceEventArgs : EventArgs
{
    public InstanceContext InstanceContext
    {
        get;
        set;
    }

    public InstanceEventArgs()
    {
    }

    public InstanceEventArgs(
        InstanceContext instanceContext)
    {
        InstanceContext = instanceContext;
    }
}

 

public class ObservableServiceHost : ServiceHost
{
    public event EventHandler<InstanceEventArgs> InstanceCreated;

    protected internal virtual void OnInstanceCreated(
        InstanceContext instanceContext)
    {
        EventHandler<InstanceEventArgs> handler = InstanceCreated;
        if (handler != null)
        {
            handler(this, new InstanceEventArgs(instanceContext));
        }
    }

    public ObservableServiceHost(
        object singletonInstance,
        params Uri[] baseAddresses) : base(singletonInstance, baseAddresses)
    {
    }

    public ObservableServiceHost(
        Type serviceType,
        params Uri[] baseAddresses) : base(serviceType, baseAddresses)
    {
    }

    protected override void OnOpening()
    {
        AddInstanceContextInitializers();

        base.OnOpening();
    }

    private void AddInstanceContextInitializers()
    {
        foreach (ServiceEndpoint endpoint in this.Description.Endpoints)
        {
            if (endpoint.Contract.ContractType != typeof(IMetadataExchange))
            {
                endpoint.Behaviors.Add(new InstanceCreationEndpointBehavior(this));
            }
        }
    }
}

public class InstanceCreationInitializer : IInstanceContextInitializer
{
    private ObservableServiceHost m_ObservableServiceHost;

    #region IInstanceContextInitializer Members
    public void Initialize(
        InstanceContext instanceContext,
        Message message)
    {
        if (m_ObservableServiceHost != null)
        {
            m_ObservableServiceHost.OnInstanceCreated(instanceContext);
        }
    }
    #endregion IInstanceContextInitializer Member

    public InstanceCreationInitializer(
        ObservableServiceHost observableServiceHost)
    {
        m_ObservableServiceHost = observableServiceHost;
    }
}

public class InstanceCreationEndpointBehavior : IEndpointBehavior
{
    private InstanceCreationInitializer m_InstanceCreationInitializer;

    #region IEndpointBehavior Members

    public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
    {
    }

    public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
    {
    }

    public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
    {
        endpointDispatcher.DispatchRuntime.InstanceContextInitializers.Add(
            m_InstanceCreationInitializer);
    }

    public void Validate(ServiceEndpoint endpoint)
    {
    }
    #endregion IEndpointBehavior Members

    public InstanceCreationEndpointBehavior(
        ObservableServiceHost observableServiceHost)
    {
        m_InstanceCreationInitializer = new InstanceCreationInitializer(observableServiceHost);
    }

}

static class Program
{
    static void Main(string[] args)
    {
        ObservableServiceHost serviceHost = new ObservableServiceHost(
            typeof(MyService));
        serviceHost.Open();
        serviceHost.InstanceCreated += new EventHandler<InstanceEventArgs>(serviceHost_InstanceCreated);

        Console.WriteLine("Press any key to exit application...");
        Console.WriteLine();
        Console.ReadLine();

        serviceHost.Close();
    }

    static void serviceHost_InstanceCreated(object sender, InstanceEventArgs e)
    {
        Console.WriteLine("New InstanceContext created");
    }
}

 

For this sample, we are just outputting a string every time a new IntanceContext is created (You could have this do more meaningful work). Now use the WcfTestClient or any other custom client to hit the endpoint (http://localhost:8080/MyService/).  When operations are run on the service, the “New InstanceContext created” message is written to the console:

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)]