I'm struggling with trying to find the best way to implement WCF retries. I'm hoping to make the client experience as clean as possible. There are two approaches of which I'm aware (see below). My question is: "**Is there a third approach that I'm missing? Maybe one that's the generally accepted way of doing this?**"

**Approach #1**: Create a proxy that implements the service interface. For each call to the proxy, implement retries.

```
public class Proxy : ISomeWcfServiceInterface
{
    public int Foo(int snurl)
    {
        return MakeWcfCall<int>(() => _channel.Foo(snurl));
    }

    public string Bar(string snuh)
    {
        return MakeWcfCall<string>(() => _channel.Bar(snuh));
    }

    private static T MakeWcfCall<T>(Func<T> func)
    {
        // Invoke the func and implement retries.
    }
}

```

**Approach #2**: Change MakeWcfCall() (above) to public, and have the consuming code send the func directly.

What I don't like about approach #1 is having to update the Proxy class every time the interface changes.

What I don't like about approach #2 is the client having to wrap their call in a func.

Am I missing a better way?

**EDIT**

I've posted an answer here (see below), based on the accepted answer that pointed me in the right direction. I thought I'd share my code, in an answer, to help someone work through what I had to work through. Hope it helps.