How to determine that a WCF Service is ready?

I have the following scenario:

My main Application (APP1) starts a Process (SERVER1). SERVER1 hosts a WCF service via named pipe. I want to connect to this service (from APP1), but sometimes it is not yet ready.

I create the ChannelFactory, open it and let it generate a client. If I now call a method on the generated Client I receive an excpetion whitch tells me that the Enpoint was not found:

var factory = new ChannelFactory<T>(new NetNamedPipeBinding(), new EndpointAddress("net.pipe//localhost/myservice");
factory.Open()

var Client = factory.CreateChannel();
Client.Foo();

If I wait a little bit before calling the service, e开发者_如何学Goverything is fine;

var Client = factory.CreateChannel();
Thread.Sleep(2000);
Client.Foo();

How can I ensure, that the Service is ready without having to wait a random amount of time?

If the general case is that you are just waiting for this other service to start up, then you may as well use the approach of having a "Ping" method on your interface that does nothing, and retrying until this starts responding.

We do a similar thing: we try and call a ping method in a loop at startup (1 second between retries), recording in our logs (but ultimately ignoring) any TargetInvocationException that occur trying to reach our service. Once we get the first proper response, we proceed onwards.

Naturally this only covers the startup warmup case - the service could go down after a successfull ping, or it we could get a TargetInvocationException for a reason other than "the service is not ready".

You could have the service signal an event [Edited-see note] once the service host is fully open and the Opened event of the channel listener has fired. The Application would wait on the event before using its proxy.

Note: Using a named event is easy because the .NET type EventWaitHandle gives you everything you need. Using an anonymous event is preferable but a bit more work, since the .NET event wrapper types don't give you an inheritable event handle. But it's still possible if you P/Invoke the Windows DuplicateHandle API yourself to get an inheritable handle, then pass the duplicated handle's value to the child process in its command line arguments.

1. If you're using .Net 4.0 you could use WS-Discovery to make the service announce its presence via Broadcast IP.

2. The service could also send a message to a queue (MSMQ binding) with a short lifespan, say a few seconds, which your client can monitor.

3. Have the service create a signal file, then use a FileSystemWatcher in the client to detect when it gets created.

4. Just while (!alive) try { alive = client.IsAlive(); } catch { ...reconnect here... } (in your service contract, you just have IsAlive() return true)

I have had the same issue and when using net.pipe*://localhost/serviceName*, I solved it by looking at the process of the self-hosted application.

the way i did that was with a utility class, here is the code.

public static class ServiceLocator
{
    public static bool IsWcfStarted()
    {
        Process[] ProcessList = Process.GetProcesses();
        return ProcessList.Any(a => a.ProcessName.StartsWith("MyApplication.Service.Host", StringComparison.Ordinal));
    }


    public static void StartWcfHost()
    {

        string path = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

        var Process2 = new Process();
        var Start2 = new ProcessStartInfo();
        Start2.FileName = Path.Combine(path, "Service", "MyApplication.Service.Host.exe");            
        Process2.StartInfo = Start2;
        Process2.Start();
    }
}

now, my application isn't called MyApplication but you get my point... now in my client Apps that use the host i have this call:

if (!ServiceLocator.IsWcfStarted())
{
    WriteEventlog("First instance of WCF Client... starting WCF host.")
    ServiceLocator.StartWcfHost();
    int timeout=0;
    while (!ServiceLocator.IsWcfStarted()) 
    {
      timeout++;
      if(timeout> MAX_RETRY)
      {
       //show message that probably wcf host is not available, end the client
       ....
      }

    }
}

This solved 2 issues, 1. The code errors I had wend away because of the race condition, and 2 2. I know in a controlled manner if the Host crashed due to some issue or misconfiguration.

Hope it helps.

Walter

I attached an event handler to client.InnerChannel.faulted, then reduced the reliableSession to 20 seconds. Within the event handler I removed the existing handler then ran an async method to attempt to connect again and attached the event handler again. Seems to work.