Question

This answer was posted in response to this question.

It’s a little above my head right now, but is the “higher order function” supposed to be used within a client proxy class? Is this correct usage?:

public class MyProxy
{
    readonly IMyService service =
        new ChannelFactory<IMyService>("IMyService").CreateChannel();

    public ResponseObject Foo(RequestObject request)
    {
        return UseService((IMyService service) =>
            service.Bar(request));
    }

    T UseService<T>(Func<IIssueTrackerService, T> code)
    {
        bool error = true;

        try
        {
            T result = code(issueTrackerChannel);
            ((IClientChannel)issueTrackerChannel).Close();
            error = false;
            return result;
        }
        finally
        {
            if (error)
            {
                ((IClientChannel)issueTrackerChannel).Abort();
            }
        }
    } 
}

All I’m really looking for is some guidance here, and the correct way to do this.

Answer 1

This is actually not to bad. Perhaps you can cast to an ICommunicationObject instead, as the same code is required for your hosts as well.

The way to think about it is close is the friendly call. Please finish my call and return the proxy to the connection pool. Abort is “I don’t care, shut the proxy because it’s dead and also remove it from the pool because it’s dead”.

Depending on your code, you might want to abstract the “WCF Proxy” parts of the code from the function call parts if it’s possible. That way you can unit test your application logic separately from the WCF proxy code.

You may want to look at a try {} catch (CommunicationException) so you can treat your WCF exceptions separately to an application level exception too, instead of the finally.

i.e

try 
{
    try 
    {
        proxy.call();
        //app logic

        ((ICommunicationObject)proxy).Close();
    } 
    catch (SomeAppException)
    {
    //recover app exception
    }
}
catch (CommunicationException) 
{
    ((ICommunicationObject)proxy).Abort();
}