Is this a Appropriate method to safely close a proxy on WCF-calls? - wcf

Question

In my application i discovered that sometimes the Close() for a WCF-call/channels trowed errors.
And i did a little research on the subject and borrowed some code on the internet to get me started.
And now, I wonder is this the right way to go? or should i improve the solution or maybe implement something totally different?
Generic-Class/Static Class:
public class SafeProxy<Service> : IDisposable where Service : ICommunicationObject
{
private readonly Service _proxy;
public SafeProxy(Service s)
{
_proxy = s;
}
public Service Proxy
{
get { return _proxy; }
}
public void Dispose()
{
if (_proxy != null)
_proxy.SafeClose();
}
}
public static class Safeclose
{
public static void SafeClose(this ICommunicationObject proxy)
{
try
{
proxy.Close();
}
catch
{
proxy.Abort();
}
}
}
This is how i make calls to the WCF:
(The WCFReference is a Service Reference pointing to the WCF service adress)
using (var Client = new SafeProxy<WCFReference.ServiceClient>(new WCFReference.ServiceClient()))
{
Client.Proxy.Operation(info);
}

Answer 1

Here's a quick little extension method I use to safely interact with a WCF service from the client:
/// <summary>
/// Helper class for WCF clients.
/// </summary>
internal static class WcfClientUtils
{
/// <summary>
/// Executes a method on the specified WCF client.
/// </summary>
/// <typeparam name="T">The type of the WCF client.</typeparam>
/// <typeparam name="TU">The return type of the method.</typeparam>
/// <param name="client">The WCF client.</param>
/// <param name="action">The method to execute.</param>
/// <returns>A value from the executed method.</returns>
/// <exception cref="CommunicationException">A WCF communication exception occurred.</exception>
/// <exception cref="TimeoutException">A WCF timeout exception occurred.</exception>
/// <exception cref="Exception">Another exception type occurred.</exception>
public static TU Execute<T, TU>(this T client, Func<T, TU> action) where T : class, ICommunicationObject
{
if ((client == null) || (action == null))
{
return default(TU);
}
try
{
return action(client);
}
catch (CommunicationException)
{
client.Abort();
throw;
}
catch (TimeoutException)
{
client.Abort();
throw;
}
catch
{
if (client.State == CommunicationState.Faulted)
{
client.Abort();
}
throw;
}
finally
{
try
{
if (client.State != CommunicationState.Faulted)
{
client.Close();
}
}
catch
{
client.Abort();
}
}
}
}
I call it as such:
var result = new WCFReference.ServiceClient().Execute(client => client.Operation(info));