我喜欢在using块中实例化我的WCF服务客户端，因为它几乎是使用实现IDisposable的资源的标准方法：
using (var client = new SomeWCFServiceClient())
{
//Do something with the client
}
但是，正如this MSDN article中所述，在using块中包装WCF客户端可能会掩盖导致客户端处于故障状态的任何错误（如超时或通信问题）。简而言之，当调用Dispose（）时，客户端的Close（）方法会触发，但会因为处于故障状态而抛出错误。然后，第二个异常掩盖了原始异常。不好。
MSDN文章中建议的解决方法是完全避免使用using块，而是实例化您的客户端并使用它们：
try
{
...
client.Close();
}
catch (CommunicationException e)
{
...
client.Abort();
}
catch (TimeoutException e)
{
...
client.Abort();
}
catch (Exception e)
{
...
client.Abort();
throw;
}
与using区块相比，我认为这很难看。每次需要客户端时都需要编写很多代码。
幸运的是，我发现了一些其他的解决方法，例如IServiceOriented上的这个。你从：
开始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;
try
{
codeBlock((T)proxy);
proxy.Close();
success = true;
}
finally
{
if (!success)
{
proxy.Abort();
}
}
}
}
然后允许：
Service<IOrderService>.Use(orderService =>
{
orderService.PlaceOrder(request);
});
这不错，但我认为它不像using阻止那样具有表现力和容易理解。
我目前正在尝试使用的解决方法我首先阅读blog.davidbarret.net。基本上，无论您在何处使用它，都会覆盖客户端的Dispose()方法。类似的东西：
public partial class SomeWCFServiceClient : IDisposable
{
void IDisposable.Dispose()
{
if (this.State == CommunicationState.Faulted)
{
this.Abort();
}
else
{
this.Close();
}
}
}
这似乎能够再次允许using阻止而没有掩盖故障状态异常的危险。
那么，有什么其他问题我需要注意使用这些变通方法吗？有没有人想出更好的东西？
答案 0 :(得分：130)
实际上，虽然我blogged（请参阅Luke's answer），但我认为this比我的IDisposable包装更好。典型代码：
Service<IOrderService>.Use(orderService=>
{
orderService.PlaceOrder(request);
});
（根据评论编辑）
由于Use返回void，处理返回值的最简单方法是通过捕获的变量：
int newOrderId = 0; // need a value for definite assignment
Service<IOrderService>.Use(orderService=>
{
newOrderId = orderService.PlaceOrder(request);
});
Console.WriteLine(newOrderId); // should be updated
答案 1 :(得分：86)
考虑到IServiceOriented.com倡导的解决方案和David Barret's blog倡导的解决方案之间的选择，我更喜欢通过覆盖客户端的Dispose（）方法提供的简单性。这允许我继续使用using（）声明，就像一个一次性对象所期望的那样。但是，正如@Brian指出的那样，这个解决方案包含一个竞争条件，因为状态在检查时可能不会出现故障，但可能在调用Close（）时发生，在这种情况下，仍然会发生CommunicationException。
所以，为了解决这个问题，我采用的是一种混合两全其美的解决方案。
void IDisposable.Dispose()
{
bool success = false;
try
{
if (State != CommunicationState.Faulted)
{
Close();
success = true;
}
}
finally
{
if (!success)
Abort();
}
}
答案 2 :(得分：30)
我写了higher order function以使其正常工作。我们已经在几个项目中使用了它，它看起来效果很好。这就是从一开始就应该做的事情，没有“使用”范例等。
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();
}
}
}
你可以这样打电话：
int a = 1;
int b = 2;
int sum = UseService((ICalculator calc) => calc.Add(a, b));
Console.WriteLine(sum);
这与你的例子中的情况非常相似。在某些项目中，我们编写强类型辅助方法，因此我们最终编写了诸如“Wcf.UseFooService（f =＆gt; f ...）”之类的内容。
我发现它非常优雅，考虑到所有事情。你遇到了一个特殊的问题吗？
这允许插入其他漂亮的功能。例如，在一个站点上，站点代表登录用户对服务进行身份验证。 （该站点本身没有凭据。）通过编写我们自己的“UseService”方法帮助程序，我们可以按照我们想要的方式配置通道工厂等。我们也不必使用生成的代理 - 任何接口都可以
答案 3 :(得分：27)
这是Microsoft推荐的处理WCF客户端调用的方法：
有关详细信息，请参阅：Expected Exceptions
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_Samples \ WCF \基本\客户\ ExpectedExceptions \ CS \客户端
考虑到在这个问题上有很多问题involving the using statement，(heated?) Internal discussions和threads，我不会浪费时间试图成为一名代码牛仔并找到一个更清洁的人办法。我只是简单地说，并为我的服务器应用程序实现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
}
不可否认，这是一个很平常的代码。我目前更喜欢this answer，并且在该代码中看不到任何可能导致问题的“黑客”。
答案 4 :(得分：14)
我终于找到了解决这个问题的一个坚实步骤。
此自定义工具扩展了WCFProxyGenerator以提供异常处理代理。它生成一个名为
ExceptionHandlingProxy<T>的附加代理，它继承ExceptionHandlingProxyBase<T>- 后者实现了代理功能。结果是您可以选择使用继承ClientBase<T>或ExceptionHandlingProxy<T>的默认代理，该代理封装管理通道工厂和通道的生命周期。 ExceptionHandlingProxy在“添加服务引用”对话框中尊重您对异步方法和集合类型的选择。
Codeplex有一个名为异常处理WCF代理生成器的项目。它基本上为Visual Studio 2008安装了一个新的自定义工具，然后使用此工具生成新的服务代理（添加服务引用）。它有一些很好的功能来处理故障通道，超时和安全处置。这里有一个很棒的视频，名为ExceptionHandlingProxyWrapper，详细说明了它是如何工作的。
您可以再次安全地使用Using语句，如果通道在任何请求（TimeoutException或CommunicationException）上出现故障，Wrapper将重新初始化故障通道并重试查询。如果失败则会调用Abort()命令并处理代理并重新抛出异常。如果服务抛出FaultException代码，它将停止执行，代理将被安全中止，抛出正常的异常。
答案 5 :(得分：10)
根据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一起使用。
如果开发人员想要手动处理代理/频道，则会暴露扩展方法。
答案 6 :(得分：8)
@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;
}
}
或者(Func<T, TResult>)
Service<IOrderService>.Use
这会使返回变量更容易。
答案 7 :(得分：7)
这是什么？
这是已接受答案的CW版本，但有（我认为完整的）包括异常处理。
接受的答案参考this website that is no longer around。为了省去麻烦，我在这里列出了最相关的部分。另外，我稍微修改了它以包含exception retry handling来处理那些讨厌的网络超时。
简单的WCF客户端使用
生成客户端代理后，只需执行此操作即可。
Service<IOrderService>.Use(orderService=>
{
orderService.PlaceOrder(request);
});
<强> ServiceDelegate.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 );
}
}
}
PS：我已将此帖发布为社区维基。我不会从这个答案中收集“积分”，但如果您同意实施，或者编辑它以使其更好，我倾向于赞成它。
答案 8 :(得分：7)
以下是来自the question的源代码的增强版本，并扩展为缓存多个渠道工厂，并尝试按合同名称在配置文件中查找端点。
它使用.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.");
}
}
答案 9 :(得分：5)
这样的包装器可以工作：
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
}
}
}
这应该使您能够编写如下代码：
ResponseType response = null;
using(var clientWrapper = new ServiceClientWrapper<IService>())
{
var request = ...
response = clientWrapper.Channel.MyServiceCall(request);
}
// Use your response object.
如果需要，包装器当然可以捕获更多例外，但原理保持不变。
答案 10 :(得分：4)
如果您不需要IoC或正在使用自动生成的客户端（服务参考），那么您可以简单地使用包装器来管理结束，并让GC获取客户端库。处于安全状态，不会抛出任何异常。 GC将在serviceclient中调用Dispose，这将调用Close。由于它已被关闭，因此不会造成任何损害。我在生产代码中使用它没有问题。
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;
}
}
}
然后，当您访问服务器时，您创建客户端并在autodisconect中使用using：
var Ws = new ServiceClient("netTcpEndPointName");
using (new AutoCloseWcf(Ws)) {
Ws.Open();
Ws.Test();
}
答案 11 :(得分：4)
我使用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 Dynamic Proxy
答案 12 :(得分：3)
使用扩展方法：
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;
}
}
答案 13 :(得分：3)
使用本答案中描述的技术，可以使用以下语法在using块中使用WCF服务：
var channelFactory = new ChannelFactory<IMyService>("");
var serviceHelper = new ServiceHelper<IMyService>(channelFactory);
var proxy = serviceHelper.CreateChannel();
using (proxy as IDisposable)
{
proxy.DoWork();
}
您当然可以进一步调整这一点以实现特定于您的情况的更简洁的编程模型 - 但关键是我们可以创建IMyService的实现来表示正确实现一次性模式的通道。 / p>
到目前为止给出的所有答案都解决了绕过＆＃34; bug＆＃34;在IDisposable的WCF频道实施中。似乎提供最简洁的编程模型（允许您使用using块来处置非托管资源）的答案是this one - 修改代理以实现IDisposable的代理无bug实现。这种方法的问题是可维护性 - 我们必须为我们使用的代理重新实现此功能。在这个答案的变体中，我们将看到我们如何使用组合而不是继承来使这种技术变得通用。
似乎有IDisposable实现的各种实现，但为了论证，我们将使用currently accepted answer使用的自适应。
[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();
}
}
有了上述课程，我们现在可以写
了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块来使用我们的服务：
ServiceHelper serviceHelper = ...;
var proxy = serviceHelper.CreateChannel();
using (proxy as IDisposable)
{
proxy.DoWork();
}
到目前为止，我们所做的只是改编Tomas' solution。阻止此代码通用的原因是必须为我们想要的每个服务契约重新实现ProxyWrapper类。我们现在将看一个允许我们使用IL动态创建此类型的类：
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();
}
}
使用我们的新助手类，我们现在可以编写
var channelFactory = new ChannelFactory<IMyService>("");
var serviceHelper = new ServiceHelper<IMyService>(channelFactory);
var proxy = serviceHelper.CreateChannel();
using (proxy as IDisposable)
{
proxy.DoWork();
}
请注意，对于继承ClientBase<>的自动生成的客户端（而不是使用ChannelFactory<>），或者如果要使用不同的实现，您也可以使用相同的技术（稍作修改） IDisposable关闭您的频道。
答案 14 :(得分：2)
我喜欢这种关闭连接的方式：
var client = new ProxyClient();
try
{
...
client.Close();
}
finally
{
if(client.State != CommunicationState.Closed)
client.Abort();
}
答案 15 :(得分：1)
我写了a simple base class来处理这个问题。它以NuGet package的形式提供，使用起来非常简单。
//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);
}
}
答案 16 :(得分：1)
我们的系统架构通常使用Unity IoC框架来创建ClientBase的实例，因此没有确定的方法可以强制其他开发人员使用using{}块。为了使它尽可能简化，我创建了这个扩展ClientBase的自定义类，并处理关闭dispose上的通道，或者在有人没有明确处理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);
}
}
}
答案 17 :(得分：1)
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);
});
答案 18 :(得分：1)
对于那些感兴趣的人，这里是接受答案的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
答案 19 :(得分：1)
我想在Marc Gravell's answer添加Service的实现，以便使用ServiceClient而不是ChannelFactory。
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();
}
}
}
}
答案 20 :(得分：0)
我这样做的方法是创建一个显式实现IDisposable的继承类。这对使用gui添加服务引用（添加服务引用）的人很有用。我只是将这个类放在制作服务引用的项目中，并使用它而不是默认的客户端：
SELECT existing_table.*, table1.columnname
FROM existing_table, table1
WHERE . . .
注意：这只是一个简单的dispose实现，如果你愿意，你可以实现更复杂的配置逻辑。
然后，您可以将使用常规服务客户端进行的所有呼叫替换为安全客户端，如下所示：
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..
}
}
}
我喜欢这个解决方案，因为它不需要我访问接口定义，我可以像我期望的那样使用using (MyServiceClientSafe client = new MyServiceClientSafe())
{
var result = client.MyServiceMethod();
}
语句，同时允许我的代码看起来或多或少相同。
您仍然需要处理此线程中其他注释中指出的可抛出的异常。
答案 21 :(得分：0)
覆盖客户端的Dispose（），无需基于ClientBase生成代理类，也无需manage channel creation and caching！ （请注意，WcfClient不是ABSTRACT类，基于ClientBase）
// 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();
}
}
答案 22 :(得分：0)
以下助手允许调用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;
});
}
}
答案 23 :(得分：0)
我有一个自己的封装器，用于实现Dispose的通道，如下所示：
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;
}
}
这似乎运作良好，允许使用使用块。
答案 24 :(得分：0)
我在这篇文章中提到了几个答案，并根据我的需要进行了定制。
我希望能够在使用之前使用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;
}
}
这是辅助类：
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));
答案 25 :(得分：-2)
您还可以使用DynamicProxy扩展Dispose()方法。这样你可以做类似的事情：
using (var wrapperdProxy = new Proxy<yourProxy>())
{
// Do whatever and dispose of Proxy<yourProxy> will be called and work properly.
}