关于c＃：WCF客户端“使用”块问题的最佳解决方法是什么？

What is the best workaround for the WCF client `using` block issue?

我喜欢在using块中实例化我的wcf服务客户机，因为它几乎是使用实现IDisposable的资源的标准方法：

1
2
3
4

using (var client = new SomeWCFServiceClient())
{
//Do something with the client
}

但是，正如本msdn文章中提到的，将wcf客户机包装在using块中可能会掩盖导致客户机处于故障状态(如超时或通信问题)的任何错误。长话短说，调用Dispose()时，客户端的close()方法将激发，但由于处于错误状态而引发错误。原始异常随后被第二个异常屏蔽。不好的。

在msdn文章中建议的解决方法是完全避免使用using块，而是实例化您的客户机并使用它们，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

try
{
...
client.Close();
}
catch (CommunicationException e)
{
...
client.Abort();
}
catch (TimeoutException e)
{
...
client.Abort();
}
catch (Exception e)
{
...
client.Abort();
throw;
}

与using区块相比，我认为这是丑陋的。每次需要客户机时都要编写大量代码。

幸运的是，我发现了一些其他的解决办法，比如在iSeviceOriented上找到的这个。你从开始：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这样就可以：

1
2
3
4

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

这还不错，但我不认为它像using块那样具有表达力和易于理解。

我在blog.davidbarret.net上第一次看到了我正在尝试使用的解决方案。基本上，无论您在何处使用客户机的Dispose()方法，都会覆盖它。类似：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public partial class SomeWCFServiceClient : IDisposable
{
void IDisposable.Dispose()
{
if (this.State == CommunicationState.Faulted)
{
this.Abort();
}
else
{
this.Close();
}
}
}

这似乎能够再次允许using块，而不存在掩盖故障状态异常的危险。

那么，有没有其他的问题需要我注意使用这些解决方法呢？有人想出更好的办法吗？

相关讨论

事实上，尽管我在博客上(见卢克的回答)，我认为这比我的IDisposable包装更好。典型代码：

1
2
3
4

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

(根据注释编辑)

由于Use返回void，处理返回值的最简单方法是通过捕获的变量：

1
2
3
4
5
6

int newOrderId = 0; // need a value for definite assignment
Service<IOrderService>.Use(orderService=>
{
newOrderId = orderService.PlaceOrder(request);
});
Console.WriteLine(newOrderId); // should be updated

相关讨论

考虑到ISeviceoriented.com所倡导的解决方案和David Barret的博客所倡导的解决方案之间的选择，我更喜欢覆盖客户机的Dispose()方法所提供的简单性。这允许我继续使用using()语句，正如对可释放对象所期望的那样。但是，正如@brian指出的那样，此解决方案包含一个争用条件，即在检查状态时，状态可能不会出错，但在调用close()时可能会出错，在这种情况下，通信异常仍然会发生。

所以，为了解决这个问题，我采用了一种混合了两个世界最好的解决方案。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

相关讨论

我写了一个高阶函数来使它正常工作。我们已经在几个项目中使用了它，而且它似乎工作得很好。这就是从一开始就应该做的事情，没有"使用"模式等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

TReturn UseService<TChannel, TReturn>(Func<TChannel, TReturn> code)
{
var chanFactory = GetCachedFactory<TChannel>();
TChannel channel = chanFactory.CreateChannel();
bool error = true;
try {
TReturn result = code(channel);
((IClientChannel)channel).Close();
error = false;
return result;
}
finally {
if (error) {
((IClientChannel)channel).Abort();
}
}
}

您可以这样打电话：

1
2
3
4

int a = 1;
int b = 2;
int sum = UseService((ICalculator calc) => calc.Add(a, b));
Console.WriteLine(sum);

这与您的示例中的情况非常相似。在一些项目中，我们编写强类型的帮助器方法，因此我们最终编写了类似"wcf.usefooseservice(f=>f…)"。

我觉得它很优雅，一切都考虑过了。你遇到了什么特别的问题吗？

这允许插入其他漂亮的功能。例如，在一个站点上，站点代表登录用户对服务进行身份验证。(站点本身没有凭证。)通过编写我们自己的"useService"方法帮助器，我们可以按照我们想要的方式配置通道工厂，等等。我们还没有绑定到使用生成的代理——任何接口都可以。

相关讨论

这是Microsoft建议的处理WCF客户端调用的方法：

有关更多详细信息，请参阅：预期异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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上问这个问题，以至于微软甚至创建了一个专门的示例来演示如何处理异常：

C:wf_wcf_sampleswcfasicclientexpectedExceptionscsclient

下载示例：C或VB

考虑到涉及使用声明的问题太多，(加热？)关于这个问题的内部讨论和线程，我不会浪费时间去尝试成为一个代码牛仔并找到一个更干净的方法。我只需要吸收它，并为我的服务器应用程序实现这种冗长(但值得信任)的WCF客户机。

要捕获的可选附加失败

许多异常源于CommunicationException，我认为这些异常中的大多数都不应该重试。我仔细检查了msdn上的每个异常，发现了一个可重试异常的简短列表(除了上面的TimeOutException)。如果我错过了一个应该重试的异常，一定要通知我。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 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
}

诚然，这是一个有点平凡的代码写。我现在更喜欢这个答案，并且在代码中没有看到任何可能导致问题的"黑客"。

相关讨论

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

This custom tool extends WCFProxyGenerator to provide an exception handling proxy. It generates an additional proxy called ExceptionHandlingProxy which inherits ExceptionHandlingProxyBase - 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 or ExceptionHandlingProxy 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)时出错，包装器将重新初始化出现故障的通道并重试查询。如果失败，它将调用Abort()命令并处理代理，然后重新引发异常。如果服务抛出一个FaultException代码，它将停止执行，代理将按预期安全地中止抛出正确的异常。

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

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();
}
}
}
}

使用实例：

1
2
3
4
5
6

string result = string.Empty;

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

它尽可能接近于"使用"语法，调用void方法时不必返回虚拟值，也可以多次调用服务(并返回多个值)，而无需使用元组。

此外，如果需要的话，您可以将它与ClientBase后代一起使用，而不是与channelFactory一起使用。

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

相关讨论

@ Marc Gravell

用这个不好吗：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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.Use的情况，与(Func)相同。

这将使返回变量更容易。

相关讨论

这是什么？

这是已接受答案的CW版本，但包含(我认为完整的)异常处理。

接受的答案引用了不再存在的网站。为了给你省事，我在这里包括了最相关的部分。另外，我稍微修改了一下，将异常重试处理包括在内，以处理那些麻烦的网络超时。

简单的WCF客户端使用

一旦生成了客户端代理，这就是实现它所需要的全部内容。

1
2
3
4

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

服务委派.cs

将此文件添加到解决方案中。不需要更改此文件，除非要更改重试次数或要处理的异常。

public delegate void UseServiceDelegate<T>(T proxy);

public static class Service<T>
{
public static ChannelFactory<T> _channelFactory = new ChannelFactory<T>("");

public static void Use(UseServiceDelegate<T> codeBlock)
{
IClientChannel proxy = (IClientChannel)_channelFactory.CreateChannel();
bool success = false;

Exception mostRecentEx = null;
int millsecondsToSleep = 1000;

for(int i=0; i<5; i++) // Attempt a maximum of 5 times
{
try
{
codeBlock((T)proxy);
proxy.Close();
success = true;
break;
}

// The following is typically thrown on the client when a channel is terminated due to the server closing the connection.
catch (ChannelTerminatedException cte)
{
mostRecentEx = cte;
proxy.Abort();
// delay (backoff) and retry
Thread.Sleep(millsecondsToSleep * (i + 1));
}

// 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)
{
mostRecentEx = enfe;
proxy.Abort();
// delay (backoff) and retry
Thread.Sleep(millsecondsToSleep * (i + 1));
}

// The following exception that is thrown when a server is too busy to accept a message.
catch (ServerTooBusyException stbe)
{
mostRecentEx = stbe;
proxy.Abort();

// delay (backoff) and retry
Thread.Sleep(millsecondsToSleep * (i + 1));
}
catch (TimeoutException timeoutEx)
{
mostRecentEx = timeoutEx;
proxy.Abort();

// delay (backoff) and retry
Thread.Sleep(millsecondsToSleep * (i + 1));
}
catch (CommunicationException comException)
{
mostRecentEx = comException;
proxy.Abort();

// delay (backoff) and retry
Thread.Sleep(millsecondsToSleep * (i + 1));
}
catch(Exception )
{
// rethrow any other exception not defined here
// You may want to define a custom Exception class to pass information such as failure count, and failure type
proxy.Abort();
throw ;
}
}
if (success == false && mostRecentEx != null)
{
proxy.Abort();
throw new Exception("WCF call failed after 5 retries.", mostRecentEx );
}

}
}

附言：我把这篇文章做成了社区维基。我不会从这个答案中收集"点"，但是如果您同意实现，我希望您对它进行上票，或者编辑它使其更好。

相关讨论

下面是来自问题的源的增强版本，扩展到缓存多个通道工厂，并尝试按合同名称在配置文件中查找端点。

它使用.NET 4(具体为：反向、LINQ、var)：

/// <summary>
/// Delegate type of the service method to perform.
/// </summary>
/// <param name="proxy">The service proxy.</param>
/// <typeparam name="T">The type of service to use.</typeparam>
internal delegate void UseServiceDelegate<in T>(T proxy);

/// <summary>
/// Wraps using a WCF service.
/// </summary>
/// <typeparam name="T">The type of service to use.</typeparam>
internal static class Service<T>
{
/// <summary>
/// A dictionary to hold looked-up endpoint names.
/// </summary>
private static readonly IDictionary<Type, string> cachedEndpointNames = new Dictionary<Type, string>();

/// <summary>
/// A dictionary to hold created channel factories.
/// </summary>
private static readonly IDictionary<string, ChannelFactory<T>> cachedFactories =
new Dictionary<string, ChannelFactory<T>>();

/// <summary>
/// Uses the specified code block.
/// </summary>
/// <param name="codeBlock">The code block.</param>
internal static void Use(UseServiceDelegate<T> codeBlock)
{
var factory = GetChannelFactory();
var proxy = (IClientChannel)factory.CreateChannel();
var success = false;

try
{
using (proxy)
{
codeBlock((T)proxy);
}

success = true;
}
finally
{
if (!success)
{
proxy.Abort();
}
}
}

/// <summary>
/// Gets the channel factory.
/// </summary>
/// <returns>The channel factory.</returns>
private static ChannelFactory<T> GetChannelFactory()
{
lock (cachedFactories)
{
var endpointName = GetEndpointName();

if (cachedFactories.ContainsKey(endpointName))
{
return cachedFactories[endpointName];
}

var factory = new ChannelFactory<T>(endpointName);

cachedFactories.Add(endpointName, factory);
return factory;
}
}

/// <summary>
/// Gets the name of the endpoint.
/// </summary>
/// <returns>The name of the endpoint.</returns>
private static string GetEndpointName()
{
var type = typeof(T);
var fullName = type.FullName;

lock (cachedFactories)
{
if (cachedEndpointNames.ContainsKey(type))
{
return cachedEndpointNames[type];
}

var serviceModel = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).SectionGroups["system.serviceModel"] as ServiceModelSectionGroup;

if ((serviceModel != null) && !string.IsNullOrEmpty(fullName))
{
foreach (var endpointName in serviceModel.Client.Endpoints.Cast<ChannelEndpointElement>().Where(endpoint => fullName.EndsWith(endpoint.Contract)).Select(endpoint => endpoint.Name))
{
cachedEndpointNames.Add(type, endpointName);
return endpointName;
}
}
}

throw new InvalidOperationException("Could not find endpoint element for type '" + fullName +"' in the ServiceModel client configuration section. This might be because no configuration file was found for your application, or because no endpoint element matching this name could be found in the client element.");
}
}

相关讨论

这样的包装可以工作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class ServiceClientWrapper<ServiceType> : IDisposable
{
private ServiceType _channel;
public ServiceType Channel
{
get { return _channel; }
}

private static ChannelFactory<ServiceType> _channelFactory;

public ServiceClientWrapper()
{
if(_channelFactory == null)
// Given that the endpoint name is the same as FullName of contract.
_channelFactory = new ChannelFactory<ServiceType>(typeof(T).FullName);
_channel = _channelFactory.CreateChannel();
((IChannel)_channel).Open();
}

public void Dispose()
{
try
{
((IChannel)_channel).Close();
}
catch (Exception e)
{
((IChannel)_channel).Abort();
// TODO: Insert logging
}
}
}

这样您就可以编写如下代码：

1
2
3
4
5
6
7

ResponseType response = null;
using(var clientWrapper = new ServiceClientWrapper<IService>())
{
var request = ...
response = clientWrapper.Channel.MyServiceCall(request);
}
// Use your response object.

如果需要的话，包装器当然可以捕获更多的异常，但是原理是相同的。

相关讨论

我使用Castle动态代理来解决dispose()问题，还实现了当通道处于不可用状态时自动刷新通道。要使用它，您必须创建一个继承您的服务合同和IDisposable的新接口。动态代理实现此接口并包装一个WCF通道：

1
2
3
4
5
6

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动态代理

如果您不需要IOC或使用自动生成的客户机(服务引用)，那么您可以简单地使用包装器来管理关闭，并让GC在安全状态下(不会引发任何异常)获取客户机库。GC将在serviceclient中调用dispose，这将调用Close。由于它已经关闭，因此不会造成任何损坏。我在生产代码中使用这个没有问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class AutoCloseWcf : IDisposable
{

private ICommunicationObject CommunicationObject;

public AutoDisconnect(ICommunicationObject CommunicationObject)
{
this.CommunicationObject = CommunicationObject;
}

public void Dispose()
{
if (CommunicationObject == null)
return;
try {
if (CommunicationObject.State != CommunicationState.Faulted) {
CommunicationObject.Close();
} else {
CommunicationObject.Abort();
}
} catch (CommunicationException ce) {
CommunicationObject.Abort();
} catch (TimeoutException toe) {
CommunicationObject.Abort();
} catch (Exception e) {
CommunicationObject.Abort();
//Perhaps log this

} finally {
CommunicationObject = null;
}
}
}

然后在访问服务器时，创建客户机并在自动发现中使用using：

1
2
3
4
5
6
7

var Ws = new ServiceClient("netTcpEndPointName");
using (new AutoCloseWcf(Ws)) {

Ws.Open();

Ws.Test();
}

使用扩展方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public static class CommunicationObjectExtensions
{
public static TResult MakeSafeServiceCall<TResult, TService>(this TService client, Func<TService, TResult> method) where TService : ICommunicationObject
{
TResult result;

try
{
result = method(client);
}
finally
{
try
{
client.Close();
}
catch (CommunicationException)
{
client.Abort(); // Don't care about these exceptions. The call has completed anyway.
}
catch (TimeoutException)
{
client.Abort(); // Don't care about these exceptions. The call has completed anyway.
}
catch (Exception)
{
client.Abort();
throw;
}
}

return result;
}
}

总结

使用此答案中描述的技术，可以使用具有以下语法的using块中的wcf服务：

1
2
3
4
5
6
7
8

var channelFactory = new ChannelFactory<IMyService>("");

var serviceHelper = new ServiceHelper<IMyService>(channelFactory);
var proxy = serviceHelper.CreateChannel();
using (proxy as IDisposable)
{
proxy.DoWork();
}

当然，您可以进一步调整这一点，以实现更为简洁的特定于您的情况的编程模型——但要点是，我们可以创建一个IMyService的实现，它代表正确实现可弃式模式的通道。

细节

到目前为止给出的所有答案都解决了在IDisposable的WCF通道实现中绕过"bug"的问题。似乎提供了最简洁的编程模型(允许您使用using块在非托管资源上进行处理)的答案是：在该模型中，代理被修改为使用无bug实现来实现IDisposable。这种方法的问题在于可维护性——我们必须重新实现我们使用的代理的这个功能。在这个答案的一个变体中，我们将看到如何使用组合而不是继承使这个技术成为通用的。

第一次尝试

对于IDisposable的实现，似乎有各种各样的实现，但是为了论证起见，我们将使用当前接受的答案所使用的方法的改编。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

[ServiceContract]
public interface IMyService
{
[OperationContract]
void DoWork();
}

public class ProxyDisposer : IDisposable
{
private IClientChannel _clientChannel;

public ProxyDisposer(IClientChannel clientChannel)
{
_clientChannel = clientChannel;
}

public void Dispose()
{
var success = false;
try
{
_clientChannel.Close();
success = true;
}
finally
{
if (!success)
_clientChannel.Abort();
_clientChannel = null;
}
}
}

public class ProxyWrapper : IMyService, IDisposable
{
private IMyService _proxy;
private IDisposable _proxyDisposer;

public ProxyWrapper(IMyService proxy, IDisposable disposable)
{
_proxy = proxy;
_proxyDisposer = disposable;
}

public void DoWork()
{
_proxy.DoWork();
}

public void Dispose()
{
_proxyDisposer.Dispose();
}
}

有了以上的课程，我们现在可以写作了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class ServiceHelper
{
private readonly ChannelFactory<IMyService> _channelFactory;

public ServiceHelper(ChannelFactory<IMyService> channelFactory )
{
_channelFactory = channelFactory;
}

public IMyService CreateChannel()
{
var channel = _channelFactory.CreateChannel();
var channelDisposer = new ProxyDisposer(channel as IClientChannel);
return new ProxyWrapper(channel, channelDisposer);
}
}

这允许我们使用using块来使用我们的服务：

1
2
3
4
5
6

ServiceHelper serviceHelper = ...;
var proxy = serviceHelper.CreateChannel();
using (proxy as IDisposable)
{
proxy.DoWork();
}

使其成为通用的

到目前为止，我们所做的就是重新表述托马斯的解决方案。阻止此代码成为通用代码的原因是，必须为我们想要的每个服务合同重新实现ProxyWrapper类。现在我们将看到一个类，它允许我们使用IL动态创建此类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

public class ServiceHelper<T>
{
private readonly ChannelFactory<T> _channelFactory;

private static readonly Func<T, IDisposable, T> _channelCreator;

static ServiceHelper()
{
/**
* Create a method that can be used generate the channel.
* This is effectively a compiled verion of new ProxyWrappper(channel, channelDisposer) for our proxy type
* */
var assemblyName = Guid.NewGuid().ToString();
var an = new AssemblyName(assemblyName);
var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
var moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName);

var proxyType = CreateProxyType(moduleBuilder, typeof(T), typeof(IDisposable));

var channelCreatorMethod = new DynamicMethod("ChannelFactory", typeof(T),
new[] { typeof(T), typeof(IDisposable) });

var ilGen = channelCreatorMethod.GetILGenerator();
var proxyVariable = ilGen.DeclareLocal(typeof(T));
var disposableVariable = ilGen.DeclareLocal(typeof(IDisposable));
ilGen.Emit(OpCodes.Ldarg, proxyVariable);
ilGen.Emit(OpCodes.Ldarg, disposableVariable);
ilGen.Emit(OpCodes.Newobj, proxyType.GetConstructor(new[] { typeof(T), typeof(IDisposable) }));
ilGen.Emit(OpCodes.Ret);

_channelCreator =
(Func<T, IDisposable, T>)channelCreatorMethod.CreateDelegate(typeof(Func<T, IDisposable, T>));

}

public ServiceHelper(ChannelFactory<T> channelFactory)
{
_channelFactory = channelFactory;
}

public T CreateChannel()
{
var channel = _channelFactory.CreateChannel();
var channelDisposer = new ProxyDisposer(channel as IClientChannel);
return _channelCreator(channel, channelDisposer);
}

/**
* Creates a dynamic type analogous to ProxyWrapper, implementing T and IDisposable.
* This method is actually more generic than this exact scenario.
* */
private static Type CreateProxyType(ModuleBuilder moduleBuilder, params Type[] interfacesToInjectAndImplement)
{
TypeBuilder tb = moduleBuilder.DefineType(Guid.NewGuid().ToString(),
TypeAttributes.Public | TypeAttributes.Class);

var typeFields = interfacesToInjectAndImplement.ToDictionary(tf => tf,
tf => tb.DefineField("_" + tf.Name, tf, FieldAttributes.Private));

#region Constructor

var constructorBuilder = tb.DefineConstructor(
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName,
CallingConventions.Standard,
interfacesToInjectAndImplement);

var il = constructorBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, typeof(object).GetConstructor(new Type[0]));

for (var i = 1; i <= interfacesToInjectAndImplement.Length; i++)
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg, i);
il.Emit(OpCodes.Stfld, typeFields[interfacesToInjectAndImplement[i - 1]]);
}
il.Emit(OpCodes.Ret);

#endregion

#region Add Interface Implementations

foreach (var type in interfacesToInjectAndImplement)
{
tb.AddInterfaceImplementation(type);
}

#endregion

#region Implement Interfaces

foreach (var type in interfacesToInjectAndImplement)
{
foreach (var method in type.GetMethods())
{
var methodBuilder = tb.DefineMethod(method.Name,
MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig |
MethodAttributes.Final | MethodAttributes.NewSlot,
method.ReturnType,
method.GetParameters().Select(p => p.ParameterType).ToArray());
il = methodBuilder.GetILGenerator();

if (method.ReturnType == typeof(void))
{
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, typeFields[type]);
il.Emit(OpCodes.Callvirt, method);
il.Emit(OpCodes.Ret);
}
else
{
il.DeclareLocal(method.ReturnType);

il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, typeFields[type]);

var methodParameterInfos = method.GetParameters();
for (var i = 0; i < methodParameterInfos.Length; i++)
il.Emit(OpCodes.Ldarg, (i + 1));
il.Emit(OpCodes.Callvirt, method);

il.Emit(OpCodes.Stloc_0);
var defineLabel = il.DefineLabel();
il.Emit(OpCodes.Br_S, defineLabel);
il.MarkLabel(defineLabel);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ret);
}

tb.DefineMethodOverride(methodBuilder, method);
}
}

#endregion

return tb.CreateType();
}
}

通过我们的新助手类，我们现在可以编写

1
2
3
4
5
6
7
8

请注意，对于为ClientBase<>继承的自动生成客户机(而不是使用ChannelFactory<>继承)，或者如果要使用IDisposable的不同实现来关闭通道，也可以使用相同的技术(稍作修改)。

我喜欢这种闭合连接的方式：

1
2
3
4
5
6
7
8
9
10
11

var client = new ProxyClient();
try
{
...
client.Close();
}
finally
{
if(client.State != CommunicationState.Closed)
client.Abort();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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();
}
}
}
}

所以它可以很好地编写返回语句：

1
2
3
4

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

对于那些感兴趣的人，这里有一个被接受答案的vb.net翻译(如下)。为了简洁起见，我对它进行了一些改进，将这条线中的一些提示与其他提示结合起来。

我承认，对于原始标签(c)来说，这是一个非主题，但是由于我找不到这个优秀解决方案的vb.net版本，我假设其他人也会找。lambda转换可能有点棘手，所以我想为某人省去麻烦。

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

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

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

用途：

1
2
3
4
5
6
7
8
9
10
11

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

我编写了一个简单的基类来处理这个问题。它可以作为一个Nuget包提供，而且很容易使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

//MemberServiceClient is the class generated by SvcUtil
public class MemberServiceManager : ServiceClientBase<MemberServiceClient>
{
public User GetUser(int userId)
{
return PerformServiceOperation(client => client.GetUser(userId));
}

//you can also check if any error occured if you can't throw exceptions
public bool TryGetUser(int userId, out User user)
{
return TryPerformServiceOperation(c => c.GetUser(userId), out user);
}
}

相关讨论

我想从MarcGravell对使用ServiceClient而不是ChannelFactory的案例的答案中添加服务的实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public interface IServiceConnector<out TServiceInterface>
{
void Connect(Action<TServiceInterface> clientUsage);
TResult Connect<TResult>(Func<TServiceInterface, TResult> channelUsage);
}

internal class ServiceConnector<TService, TServiceInterface> : IServiceConnector<TServiceInterface>
where TServiceInterface : class where TService : ClientBase<TServiceInterface>, TServiceInterface, new()
{
public TResult Connect<TResult>(Func<TServiceInterface, TResult> channelUsage)
{
var result = default(TResult);
Connect(channel =>
{
result = channelUsage(channel);
});
return result;
}

public void Connect(Action<TServiceInterface> clientUsage)
{
if (clientUsage == null)
{
throw new ArgumentNullException("clientUsage");
}
var isChanneldClosed = false;
var client = new TService();
try
{
clientUsage(client);
client.Close();
isChanneldClosed = true;
}
finally
{
if (!isChanneldClosed)
{
client.Abort();
}
}
}
}

我们的系统体系结构通常使用Unity IOC框架来创建ClientBase实例，因此没有可靠的方法来强制其他开发人员甚至使用using{}块。为了使它尽可能的简单，我创建了这个扩展ClientBase的自定义类，并在Dispose时处理关闭通道，或者在Finalize时处理，以防有人没有显式地处理Unity创建的实例。

在构造器中还需要做一些事情来设置自定义凭证和东西的通道，所以这里也有一些事情……

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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;
}
}
}

然后客户可以简单地：

1
2
3
4
5
6
7

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

呼叫方可以执行以下任一操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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);
}
}
}

相关讨论

我这样做的方法是创建一个显式实现IDisposable的继承类。这对于使用GUI添加服务引用(添加服务引用)的人员很有用。我只是将这个类放到生成服务引用的项目中，并使用它而不是默认的客户机：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

using System;
using System.ServiceModel;
using MyApp.MyService; // The name you gave the service namespace

namespace MyApp.Helpers.Services
{
public class MyServiceClientSafe : MyServiceClient, IDisposable
{
void IDisposable.Dispose()
{
if (State == CommunicationState.Faulted)
{
Abort();
}
else if (State != CommunicationState.Closed)
{
Close();
}

// Further error checks and disposal logic as desired..
}
}
}

注意：这只是Dispose的一个简单实现，如果愿意，您可以实现更复杂的Dispose逻辑。

然后，您可以将常规服务客户机发出的所有呼叫替换为安全客户机，如下所示：

1
2
3
4

using (MyServiceClientSafe client = new MyServiceClientSafe())
{
var result = client.MyServiceMethod();
}

我喜欢这个解决方案，因为它不需要我访问接口定义，我可以像预期的那样使用using语句，同时允许我的代码看起来或多或少相同。

您仍然需要处理这个线程中的其他注释中指出的可以抛出的异常。

下面的助手允许调用void和非void方法。用途：

1
2
3

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

类本身是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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;
});
}
}

我有自己的通道包装器，该通道实现如下处置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public void Dispose()
{
try
{
if (channel.State == CommunicationState.Faulted)
{
channel.Abort();
}
else
{
channel.Close();
}
}
catch (CommunicationException)
{
channel.Abort();
}
catch (TimeoutException)
{
channel.Abort();
}
catch (Exception)
{
channel.Abort();
throw;
}
}

这似乎很有效，允许使用一个using块。

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

我希望在使用WCF客户机之前能够对它做些什么，所以使用DoSomethingWithClient()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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;
}
}

这是帮助程序类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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();
}
}
}
}

我可以用它作为：

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

相关讨论

重写客户端的dispose()，而不需要基于clientbase生成代理类，也不需要管理通道创建和缓存！(请注意，wcfclient不是抽象类，它基于clientbase)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// No need for a generated proxy class
//using (WcfClient<IOrderService> orderService = new WcfClient<IOrderService>())
//{
// results = orderService.GetProxy().PlaceOrder(input);
//}

public class WcfClient<TService> : ClientBase<TService>, IDisposable
where TService : class
{
public WcfClient()
{
}

public WcfClient(string endpointConfigurationName) :
base(endpointConfigurationName)
{
}

public WcfClient(string endpointConfigurationName, string remoteAddress) :
base(endpointConfigurationName, remoteAddress)
{
}

public WcfClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) :
base(endpointConfigurationName, remoteAddress)
{
}

public WcfClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :
base(binding, remoteAddress)
{
}

protected virtual void OnDispose()
{
bool success = false;

if ((base.Channel as IClientChannel) != null)
{
try
{
if ((base.Channel as IClientChannel).State != CommunicationState.Faulted)
{
(base.Channel as IClientChannel).Close();
success = true;
}
}
finally
{
if (!success)
{
(base.Channel as IClientChannel).Abort();
}
}
}
}

public TService GetProxy()
{
return this.Channel as TService;
}

public void Dispose()
{
OnDispose();
}
}

相关讨论

您还可以使用DynamicProxy来扩展Dispose()方法。这样你就可以做到：

1
2
3
4

using (var wrapperdProxy = new Proxy<yourProxy>())
{
// Do whatever and dispose of Proxy<yourProxy> will be called and work properly.
}