@Marc Gravell

用这个不是很好吗:

public static TResult Using<T, TResult>(this T client, Func<T, TResult> work)
        where T : ICommunicationObject
{
    try
    {
        var result = work(client);

        client.Close();

        return result;
    }
    catch (Exception e)
    {
        client.Abort();

        throw;
    }
}

或者在Service<IOrderService>的情况下，同样的事情(Func<T, TResult>)。使用

这将使返回变量更容易。

这是微软推荐的处理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”。

Given a choice between the solution advocated by IServiceOriented.com and the solution advocated by David Barret's blog, I prefer the simplicity offered by overriding the client's Dispose() method. This allows me to continue to use the using() statement as one would expect with a disposable object. However, as @Brian pointed out, this solution contains a race condition in that the State might not be faulted when it is checked but could be by the time Close() is called, in which case the CommunicationException still occurs.

因此，为了解决这个问题，我采用了一种混合了两种方法的解决方案。

void IDisposable.Dispose()
{
    bool success = false;
    try 
    {
        if (State != CommunicationState.Faulted) 
        {
            Close();
            success = true;
        }
    } 
    finally 
    {
        if (!success) 
            Abort();
    }
}

public static class Service<TChannel>
{
    public static ChannelFactory<TChannel> ChannelFactory = new ChannelFactory<TChannel>("*");

    public static TReturn Use<TReturn>(Func<TChannel,TReturn> codeBlock)
    {
        var proxy = (IClientChannel)ChannelFactory.CreateChannel();
        var success = false;
        try
        {
            var result = codeBlock((TChannel)proxy);
            proxy.Close();
            success = true;
            return result;
        }
        finally
        {
            if (!success)
            {
                proxy.Abort();
            }
        }
    }
}

所以它允许很好地编写return语句:

return Service<IOrderService>.Use(orderService => 
{ 
    return orderService.PlaceOrder(request); 
}); 

我使用Castle动态代理来解决Dispose()问题，并在通道处于不可用状态时实现自动刷新。要使用此功能，必须创建一个继承服务契约和IDisposable的新接口。动态代理实现了这个接口，并封装了一个WCF通道:

Func<object> createChannel = () =>
    ChannelFactory<IHelloWorldService>
        .CreateChannel(new NetTcpBinding(), new EndpointAddress(uri));
var factory = new WcfProxyFactory();
var proxy = factory.Create<IDisposableHelloWorldService>(createChannel);
proxy.HelloWorld();

我喜欢这样做，因为您可以注入WCF服务，而使用者无需担心WCF的任何细节。它不像其他解那样有额外的麻烦。

看一下代码，其实很简单: WCF动态代理

对于那些感兴趣的人，这里有一个VB。NET翻译的公认答案(如下)。为了简洁起见，我结合了这篇文章中其他人的一些建议，对它进行了一些改进。

我承认这是偏离主题的原始标签(c#)，但我不能找到一个VB。NET版本的这个很好的解决方案，我想其他人也会关注的。Lambda翻译可能有点棘手，所以我想省去一些麻烦。

注意，这个特殊的实现提供了在运行时配置ServiceEndpoint的能力。

代码:

Namespace Service
  Public NotInheritable Class Disposable(Of T)
    Public Shared ChannelFactory As New ChannelFactory(Of T)(Service)

    Public Shared Sub Use(Execute As Action(Of T))
      Dim oProxy As IClientChannel

      oProxy = ChannelFactory.CreateChannel

      Try
        Execute(oProxy)
        oProxy.Close()

      Catch
        oProxy.Abort()
        Throw

      End Try
    End Sub



    Public Shared Function Use(Of TResult)(Execute As Func(Of T, TResult)) As TResult
      Dim oProxy As IClientChannel

      oProxy = ChannelFactory.CreateChannel

      Try
        Use = Execute(oProxy)
        oProxy.Close()

      Catch
        oProxy.Abort()
        Throw

      End Try
    End Function



    Public Shared ReadOnly Property Service As ServiceEndpoint
      Get
        Return New ServiceEndpoint(
          ContractDescription.GetContract(
            GetType(T),
            GetType(Action(Of T))),
          New BasicHttpBinding,
          New EndpointAddress(Utils.WcfUri.ToString))
      End Get
    End Property
  End Class
End Namespace

用法:

Public ReadOnly Property Jobs As List(Of Service.Job)
  Get
    Disposable(Of IService).Use(Sub(Client) Jobs = Client.GetJobs(Me.Status))
  End Get
End Property

Public ReadOnly Property Jobs As List(Of Service.Job)
  Get
    Return Disposable(Of IService).Use(Function(Client) Client.GetJobs(Me.Status))
  End Get
End Property