CODEWITHSUNDEEP
silverlightwcf
Jonathan Allen
Jonathan Allen

Reputation: 70337

WCF/Silverlight: How can I foul a Channel?

I was told that I shouldn't cache channels in Silverlight/WCF because they may become faulted and unsuable. Can somone show me some sample code that would prove it can happen.

  1. Call a service to prove the connection can work (i.e. no bogus URL)
  2. Make a second call that fouls the channel by causing it to go into a faulted condition
  3. Repeat the first call, which would fail.

Upvotes: 0

Views: 185

Answers (1)

Ken Smith
Ken Smith

Reputation: 20445

In my own testing, the key is whether the binding you're using is session-oriented or not. If you're using a stateless binding like BasicHttpBinding, you can muck up the channel all you want and you're good. For instance, I've got a WCF service using the BasicHttpBinding that looks like this -- note specifically the Channel.Abort() call in SayGoodbye():

public class HelloWorldService : IHelloWorldService
{
    public string SayHello()
    {
        return "Hello.";
    }

    public string SayGoodbye()
    {
        OperationContext.Current.Channel.Abort();
        return "Goodbye.";
    }
}

And the Silverlight client code looks like this (ugly as hell, sorry).

public partial class ServiceTestPage : Page
{

    HelloWorldServiceClient client;

    public ServiceTestPage()
    {
        InitializeComponent();
        client = new HelloWorldServiceClient();
        client.SayHelloCompleted += new EventHandler<SayHelloCompletedEventArgs>(client_SayHelloCompleted);
        client.SayGoodbyeCompleted += new EventHandler<SayGoodbyeCompletedEventArgs>(client_SayGoodbyeCompleted);
        client.SayHelloAsync();
    }

    void client_SayHelloCompleted(object sender, SayHelloCompletedEventArgs e)
    {
        if (e.Error == null)
        {
            Debug.WriteLine("Called SayHello() with result: {0}.", e.Result);
            client.SayGoodbyeAsync();
        }
        else
        {
            Debug.WriteLine("Called SayHello() with the error: {0}", e.Error.ToString());
        }
    }

    void client_SayGoodbyeCompleted(object sender, SayGoodbyeCompletedEventArgs e)
    {
        if (e.Error == null)
        {
            Debug.WriteLine("Called SayGoodbye() with result: {0}.");
        }
        else
        {
            Debug.WriteLine("Called SayGoodbye() with the error: {0}", e.Error.ToString());
        }
        client.SayHelloAsync(); // start over
    }

}

And it'll loop around infinitely as long as you want.

But if you're using a session-oriented binding like Net.TCP or HttpPollingDuplex, you've got to be much more careful about your channel handling. If that's the case, then of course you're caching your proxy client, right? What you have to do in that instance is to catch the Channel_Faulted event, abort the client, and then recreate it, and of course, re-establish all your event-handlers. Kind of a pain.

On a side note, when it comes to using a duplex binding, the best approach that I've found (I'm open to others) is to create a wrapper around my proxy client that does three things:

(1) Transforms the obnoxious event-raising code generated by the "Add Service Reference" dialog box into a far-more-useful continuation-passing pattern.

(2) Wraps each of the events raised from the server-side, so that the client can subscribe to the event on my wrapper, not the event on the proxy client itself, since the proxy client itself may have to be deleted and recreated.

(3) Handles the ChannelFaulted event, and (several times, with a timeout) attempts to recreate the proxy client. If it succeeds, it automatically resubscribes all of its event wrappers, and if it fails, it throws a real ClientFaulted event which in effect means, "You're screwed, try again later."

It's a pain, since it seems like this is the sort of thing that should have been included with the MS-generated code in the first place. But it sure fixes a whole lot of problems. One of these days I'll see if I can get this wrapper working with T4 templates.

Upvotes: 2

Related Questions