我在这篇文章中提到了一些答案，并根据我的需要定制了它。

我想在使用WCF客户端之前做一些事情，所以使用DoSomethingWithClient()方法。

public interface IServiceClientFactory<T>
{
    T DoSomethingWithClient();
}
public partial class ServiceClient : IServiceClientFactory<ServiceClient>
{
    public ServiceClient DoSomethingWithClient()
    {
        var client = this;
        // do somthing here as set client credentials, etc.
        //client.ClientCredentials = ... ;
        return client;
    }
}

下面是helper类:

public static class Service<TClient>
    where TClient : class, ICommunicationObject, IServiceClientFactory<TClient>, new()
{
    public static TReturn Use<TReturn>(Func<TClient, TReturn> codeBlock)
    {
        TClient client = default(TClient);
        bool success = false;
        try
        {
            client = new TClient().DoSomethingWithClient();
            TReturn result = codeBlock(client);
            client.Close();
            success = true;
            return result;
        }
        finally
        {
            if (!success && client != null)
            {
                client.Abort();
            }
        }
    }
}

我可以把它用作:

string data = Service<ServiceClient>.Use(x => x.GetData(7));

下面的帮助器允许调用void和非void方法。用法:

var calculator = new WcfInvoker<CalculatorClient>(() => new CalculatorClient());
var sum = calculator.Invoke(c => c.Sum(42, 42));
calculator.Invoke(c => c.RebootComputer());

类本身是:

public class WcfInvoker<TService>
    where TService : ICommunicationObject
{
    readonly Func<TService> _clientFactory;

    public WcfInvoker(Func<TService> clientFactory)
    {
        _clientFactory = clientFactory;
    }

    public T Invoke<T>(Func<TService, T> action)
    {
        var client = _clientFactory();
        try
        {
            var result = action(client);
            client.Close();
            return result;
        }
        catch
        {
            client.Abort();
            throw;
        }
    }

    public void Invoke(Action<TService> action)
    {
        Invoke<object>(client =>
        {
            action(client);
            return null;
        });
    }
}

我们的系统架构经常使用Unity IoC框架来创建ClientBase实例，所以没有确定的方法来强制其他开发人员使用{}块。为了使它尽可能的万无一难，我做了这个扩展ClientBase的自定义类，并处理在dispose时关闭通道，或者在finalize时关闭通道，以防有人没有显式地处置Unity创建的实例。

还有一些东西需要在构造函数中完成，为自定义凭证和其他东西设置通道，所以也在这里…

public abstract class PFServer2ServerClientBase<TChannel> : ClientBase<TChannel>, IDisposable where TChannel : class
{
    private bool disposed = false;

    public PFServer2ServerClientBase()
    {
        // Copy information from custom identity into credentials, and other channel setup...
    }

    ~PFServer2ServerClientBase()
    {
        this.Dispose(false);
    }

    void IDisposable.Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this);
    }

    public void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            try
            {
                    if (this.State == CommunicationState.Opened)
                        this.Close();
            }
            finally
            {
                if (this.State == CommunicationState.Faulted)
                    this.Abort();
            }
            this.disposed = true;
        }
    }
}

然后客户可以简单地:

internal class TestClient : PFServer2ServerClientBase<ITest>, ITest
{
    public string TestMethod(int value)
    {
        return base.Channel.TestMethod(value);
    }
}

调用者可以做以下任何一件事:

public SomeClass
{
    [Dependency]
    public ITest test { get; set; }

    // Not the best, but should still work due to finalizer.
    public string Method1(int value)
    {
        return this.test.TestMethod(value);
    }

    // The good way to do it
    public string Method2(int value)
    {
        using(ITest t = unityContainer.Resolve<ITest>())
        {
            return t.TestMethod(value);
        }
    }
}

我终于找到了一些明确解决这个问题的坚实步骤。

This custom tool extends WCFProxyGenerator to provide an exception handling proxy. It generates an additional proxy called ExceptionHandlingProxy<T> which inherits ExceptionHandlingProxyBase<T> - the latter of which implements the meat of the proxy's functionality. The result is that you can choose to use the default proxy that inherits ClientBase<T> or ExceptionHandlingProxy<T> which encapsulates managing the lifetime of the channel factory and channel. ExceptionHandlingProxy respects your selections in the Add Service Reference dialog with respect to asynchronous methods and collection types.

Codeplex有一个名为异常处理WCF代理生成器的项目。它基本上是在Visual Studio 2008中安装一个新的自定义工具，然后使用该工具生成新的服务代理(添加服务引用)。它有一些很好的功能来处理故障通道、超时和安全处理。这里有一个名为ExceptionHandlingProxyWrapper的优秀视频，详细解释了这是如何工作的。

您可以安全地再次使用Using语句，如果通道在任何请求(TimeoutException或CommunicationException)上发生故障，Wrapper将重新初始化故障通道并重试查询。如果失败，它将调用Abort()命令并处理代理并重新抛出异常。如果服务抛出FaultException代码，它将停止执行，代理将按照预期安全抛出正确的异常。

根据Marc Gravell、MichaelGG和Matt Davis的回答，我们的开发人员得出了以下结论:

public static class UsingServiceClient
{
    public static void Do<TClient>(TClient client, Action<TClient> execute)
        where TClient : class, ICommunicationObject
    {
        try
        {
            execute(client);
        }
        finally
        {
            client.DisposeSafely();
        }
    }

    public static void DisposeSafely(this ICommunicationObject client)
    {
        if (client == null)
        {
            return;
        }

        bool success = false;

        try
        {
            if (client.State != CommunicationState.Faulted)
            {
                client.Close();
                success = true;
            }
        }
        finally
        {
            if (!success)
            {
                client.Abort();
            }
        }
    }
}

使用示例:

string result = string.Empty;

UsingServiceClient.Do(
    new MyServiceClient(),
    client =>
    result = client.GetServiceResult(parameters));

它尽可能接近于“using”语法，在调用void方法时不必返回一个虚拟值，并且可以对服务进行多次调用(并返回多个值)，而不必使用元组。

此外，如果需要，您可以将此用于ClientBase<T>后裔，而不是ChannelFactory。

如果开发人员希望手动处理代理/通道，则会公开扩展方法。

这是微软推荐的处理WCF客户端调用的方法:

有关更多详细信息，请参见:预期异常

try
{
    ...
    double result = client.Add(value1, value2);
    ...
    client.Close();
}
catch (TimeoutException exception)
{
    Console.WriteLine("Got {0}", exception.GetType());
    client.Abort();
}
catch (CommunicationException exception)
{
    Console.WriteLine("Got {0}", exception.GetType());
    client.Abort();
}

额外的信息 很多人似乎都在WCF上问这个问题，以至于微软甚至创建了一个专门的示例来演示如何处理异常:

WCF c: \ WF_WCF_Samples \ \基本\ Client \ ExpectedExceptions \ CS \客户机

下载示例: c#或VB

考虑到使用语句有这么多的问题，(激烈?)关于这个问题的内部讨论和线程，我不会浪费时间试图成为一个代码牛仔，找到一个更干净的方法。我只是接受它，为我的服务器应用程序以这种冗长(但可信)的方式实现WCF客户机。

可选的附加失败

许多异常派生于CommunicationException，我认为大多数异常都不应该重新尝试。我费力地浏览了MSDN上的每个异常，并找到了一个可重试异常的简短列表(除了上面的TimeOutException)。如果我错过了应该重试的异常，请告诉我。

  // The following is typically thrown on the client when a channel is terminated due to the server closing the connection.
catch (ChannelTerminatedException cte)
{
secureSecretService.Abort();
// todo: Implement delay (backoff) and retry
}

// The following is thrown when a remote endpoint could not be found or reached.  The endpoint may not be found or 
// reachable because the remote endpoint is down, the remote endpoint is unreachable, or because the remote network is unreachable.
catch (EndpointNotFoundException enfe)
{
secureSecretService.Abort();
// todo: Implement delay (backoff) and retry
}

// The following exception that is thrown when a server is too busy to accept a message.
catch (ServerTooBusyException stbe)
{
secureSecretService.Abort();
// todo: Implement delay (backoff) and retry
}

诚然，这是编写的一些普通代码。我目前更喜欢这个答案，并且在代码中没有看到任何可能导致问题的“hack”。