对于WCF客户端“使用”块问题,最好的解决方案是什么?

我喜欢在using块中实例化我的WCF服务客户端,因为这几乎是使用实现IDisposable的资源的标准方式:

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

但是,正如这篇MSDN文章中所指出的,将WCF客户端包装在using块中可以掩盖任何导致客户端处于故障状态的错误(如超时或通信问题)。长话短说,当调用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块,而不会有掩盖错误状态异常的危险。

那么,使用这些变通方法还有其他需要注意的问题吗?有没有人想出更好的办法?

115999 次浏览

我写了一个高阶函数使它工作正确。我们已经在几个项目中使用了这个方法,看起来效果不错。这就是从一开始就应该做的事情,没有“使用”范式等等。

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=>f…)”这样的东西。

从各方面考虑,我觉得它相当优雅。您遇到过什么特别的问题吗?

这允许插入其他漂亮的功能。例如,在一个站点上,站点代表登录用户向服务进行身份验证。(该网站本身没有凭据。)通过编写我们自己的“UseService”方法助手,我们可以按照我们想要的方式配置通道工厂,等等。我们也不局限于使用生成的代理——任何接口都可以。

实际上,虽然我博客(参见卢克的回答),但我认为比我的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

我们的系统架构经常使用团结 国际奥委会框架来创建ClientBase实例,因此没有确定的方法强制其他开发人员使用using{}块。为了使它尽可能的万无一难,我做了这个扩展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);
}
}
}

如果要在IServiceOriented.com所倡导的解决方案和大卫·巴雷特的博客所倡导的解决方案之间进行选择,我更喜欢覆盖客户端的Dispose()方法所提供的简单性。这允许我继续使用using()语句,就像对一次性对象所期望的那样。然而,正如@Brian指出的那样,该解决方案包含一个竞态条件,即在检查状态时可能不会出错,但在调用Close()时可能会出错,在这种情况下,CommunicationException仍然会发生。

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

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

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

这个自定义工具扩展了WCFProxyGenerator来提供一个异常处理代理。它生成一个名为ExceptionHandlingProxy<T>的附加代理,该代理继承了ExceptionHandlingProxyBase<T>——后者实现了代理的主要功能。结果是,您可以选择使用继承ClientBase<T>ExceptionHandlingProxy<T>的默认代理,后者封装了管理通道工厂和通道的生命周期。ExceptionHandlingProxy尊重您在添加服务引用对话框中关于异步方法和集合类型的选择。

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

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

像这样的包装器可以工作:

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.

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

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

考虑到在这个问题上有如此多的问题使用using语句(加热)内部讨论线程,我不打算浪费我的时间试图成为一个代码牛仔,找到一个更干净的方法。我只是接受它,为我的服务器应用程序以这种冗长(但可信)的方式实现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
}

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

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

它使用。net 4(特别是:contravance, 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.");
}
}

如果你不需要国际奥委会或者正在使用一个自动生成的客户端(服务引用),那么你可以简单地使用包装器来管理关闭,并让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;
}
}
}

然后,当你访问服务器时,你创建客户端,并在autodisconnect中使用using:

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


Ws.Open();


Ws.Test();
}

我使用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动态代理 < / p >

这是什么?

这是CW版本的接受的答案,但与(我认为完整的)异常处理包括在内。

接受的答案引用这个网站已经不存在了。为了省事,我在这里列出了最相关的部分。此外,我稍微修改了它,以包括异常重试处理来处理那些讨厌的网络超时。

简单的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:我把这篇文章做成了一个社区维基。我不会从这个答案中收集“分数”,但如果你同意这个实现,或者编辑它使它更好,我更希望你给它投票。

根据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。

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

我已经写了一个简单的基类来处理这个。它可以作为NuGet包使用,并且非常容易使用。

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

@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>.Use,同样的事情(Func<T, TResult>)

这将使返回变量更容易。

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

你也可以使用DynamicProxy来扩展Dispose()方法。你可以这样做:

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

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

我想在使用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));

使用扩展方法:

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

我有我自己的包装器的通道,实现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;
}
}

这似乎工作得很好,并允许使用using块。

下面的帮助器允许调用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;
});
}
}

对于那些感兴趣的人,这里有一个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

我想从Marc Gravell的回答是中添加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();
}
}
}
}

总结

使用这个答案中描述的技术,你可以在Using块中使用一个WCF服务,语法如下:

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


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

当然,你可以进一步调整它,以实现更简洁的编程模型,具体到你的情况-但关键是,我们可以创建一个IMyService的实现,表示正确实现一次性模式的通道。


细节

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

第一次尝试

IDisposable实现似乎有各种实现,但为了便于讨论,我们将使用当前接受的答案所使用的实现的改编。

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

让它变得通用

到目前为止,我们所做的只是重新表述托马斯的解决方案。阻止这段代码成为泛型的原因是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的不同实现来关闭你的通道。

重写客户端的Dispose()而不需要生成基于ClientBase的代理类,也不需要管理通道创建和缓存!(注意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();
}
}

我喜欢这种结束联系的方式:

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

我的方法是创建一个显式实现IDisposable的继承类。这对于使用gui添加服务引用(添加服务引用)的人很有用。我只是在项目中删除这个类,使服务引用,并使用它而不是默认客户端:

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逻辑。

然后你可以用安全客户端替换常规服务客户端的所有调用,如下所示:

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

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

您仍然需要处理可以抛出的异常,正如在本线程的其他注释中指出的那样。