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

Question

I like instantiating my WCF service clients within a using block as it s pretty much the standard way to use resources that implement IDisposable  using  var client   new SomeWCFServiceClient             Do something with the client     But  as noted in this MSDN article  wrapping a WCF client in a using block could mask any errors that result in the client being left in a faulted state  like a timeout or communication problem   Long story short  when Dispose   is called  the client s Close   method fires  but throws an error because it s in a faulted state  The original exception is then masked by the second exception  Not good  The suggested workaround in the MSDN article is to completely avoid using a using block  and to instead instantiate your clients and use them something like this  try               client Close      catch  CommunicationException e                client Abort      catch  TimeoutException e                client Abort      catch  Exception e                client Abort        throw     Compared to the using block  I think that s ugly  And a lot of code to write each time you need a client  Luckily  I found a few other workarounds  such as this one on the  now defunct  IServiceOriented blog  You start with  public delegate void UseServiceDelegate lt T gt  T proxy     public static class Service lt T gt          public static ChannelFactory lt T gt   channelFactory   new ChannelFactory lt T gt   quot  quot              public static void Use UseServiceDelegate lt T gt  codeBlock                  IClientChannel proxy    IClientChannel  channelFactory CreateChannel             bool success   false           try                         codeBlock  T proxy                proxy Close                 success   true                      finally                         if   success                                  proxy Abort                                           Which then allows  Service lt IOrderService gt  Use orderService   gt          orderService PlaceOrder request          That s not bad  but I don t think it s as expressive and easily understandable as the using block  The workaround I m currently trying to use I first read about on blog davidbarret net  Basically  you override the client s Dispose   method wherever you use it  Something like  public partial class SomeWCFServiceClient   IDisposable       void IDisposable Dispose                  if  this State    CommunicationState Faulted                         this Abort                       else                        this Close                       This appears to be able to allow the using block again without the danger of masking a faulted state exception  So  are there any other gotchas I have to look out for using these workarounds  Has anybody come up with anything better

User · Answer

I wrote a higher order function to make it work right. We've used this in several projects and it seems to work great. This is how things should have been done from the start, without the "using" paradigm or so on.

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

You can make calls like this:

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

This is pretty much just like you have in your example. In some projects, we write strongly typed helper methods, so we end up writing things like "Wcf.UseFooService(f=>f...)".

I find it quite elegant, all things considered. Is there a particular problem you encountered?

This allows other nifty features to be plugged in. For instance, on one site, the site authenticates to the service on behalf of the logged in user. (The site has no credentials by itself.) By writing our own "UseService" method helper, we can configure the channel factory the way we want, etc. We're also not bound to using the generated proxies -- any interface will do.

User · Answer

I used Castle dynamic proxy to solve the Dispose   issue  and also implemented auto-refreshing the channel when it is in an unusable state   To use this you must create a new interface that inherits your service contract and IDisposable   The dynamic proxy implements this interface and wraps a WCF channel   Func lt object gt  createChannel        gt      ChannelFactory lt IHelloWorldService gt           CreateChannel new NetTcpBinding    new EndpointAddress uri    var factory   new WcfProxyFactory    var proxy   factory Create lt IDisposableHelloWorldService gt  createChannel   proxy HelloWorld      I like this since you can inject WCF services without consumers needing to worry about any details of WCF   And there s no added cruft like the other solutions   Have a look at the code  it s actually pretty simple  WCF Dynamic Proxy

User · Answer

I d like to add implementation of Service from Marc Gravell s answer for case of using ServiceClient instead of ChannelFactory   public interface IServiceConnector lt out TServiceInterface gt        void Connect Action lt TServiceInterface gt  clientUsage       TResult Connect lt TResult gt  Func lt TServiceInterface  TResult gt  channelUsage      internal class ServiceConnector lt TService  TServiceInterface gt    IServiceConnector lt TServiceInterface gt      where TServiceInterface   class where TService   ClientBase lt TServiceInterface gt   TServiceInterface  new         public TResult Connect lt TResult gt  Func lt TServiceInterface  TResult gt  channelUsage                var result   default TResult           Connect channel   gt                        result   channelUsage channel                       return result             public void Connect Action lt TServiceInterface gt  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

User · Answer

A wrapper like this would work   public class ServiceClientWrapper lt ServiceType gt    IDisposable       private ServiceType  channel      public ServiceType Channel               get   return  channel               private static ChannelFactory lt ServiceType gt   channelFactory       public ServiceClientWrapper                 if  channelFactory    null                  Given that the endpoint name is the same as FullName of contract               channelFactory   new ChannelFactory lt ServiceType gt  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                     That should enable you to write code like   ResponseType response   null  using var clientWrapper   new ServiceClientWrapper lt IService gt           var request           response   clientWrapper Channel MyServiceCall request        Use your response object    The wrapper could of course catch more exceptions if that is required  but the principle remains the same

User · Answer

public static class Service lt TChannel gt        public static ChannelFactory lt TChannel gt  ChannelFactory   new ChannelFactory lt TChannel gt             public static TReturn Use lt TReturn gt  Func lt TChannel TReturn gt  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                                      So it allows to write return statements nicely   return Service lt IOrderService gt  Use orderService   gt          return orderService PlaceOrder request

User · Answer

Below is an enhanced version of the source from the question and extended to cache multiple channel factories and attempt to look up the endpoint in the configuration file by contract name   It uses  NET 4  specifically  contravariance  LINQ  var         lt summary gt      Delegate type of the service method to perform       lt  summary gt       lt param name  proxy  gt The service proxy  lt  param gt       lt typeparam name  T  gt The type of service to use  lt  typeparam gt  internal delegate void UseServiceDelegate lt in T gt  T proxy         lt summary gt      Wraps using a WCF service       lt  summary gt       lt typeparam name  T  gt The type of service to use  lt  typeparam gt  internal static class Service lt T gt             lt summary gt          A dictionary to hold looked-up endpoint names           lt  summary gt      private static readonly IDictionary lt Type  string gt  cachedEndpointNames   new Dictionary lt Type  string gt               lt summary gt          A dictionary to hold created channel factories           lt  summary gt      private static readonly IDictionary lt string  ChannelFactory lt T gt  gt  cachedFactories           new Dictionary lt string  ChannelFactory lt T gt  gt               lt summary gt          Uses the specified code block           lt  summary gt           lt param name  codeBlock  gt The code block  lt  param gt      internal static void Use UseServiceDelegate lt T gt  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                                            lt summary gt          Gets the channel factory           lt  summary gt           lt returns gt The channel factory  lt  returns gt      private static ChannelFactory lt T gt  GetChannelFactory                 lock  cachedFactories                        var endpointName   GetEndpointName                 if  cachedFactories ContainsKey endpointName                                 return cachedFactories endpointName                              var factory   new ChannelFactory lt T gt  endpointName                cachedFactories Add endpointName  factory               return factory                            lt summary gt          Gets the name of the endpoint           lt  summary gt           lt returns gt The name of the endpoint  lt  returns gt      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   amp  amp   string IsNullOrEmpty fullName                                 foreach  var endpointName in serviceModel Client Endpoints Cast lt ChannelEndpointElement gt    Where endpoint   gt  fullName EndsWith endpoint Contract   Select endpoint   gt  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

User · Answer

Use an extension method   public static class CommunicationObjectExtensions       public static TResult MakeSafeServiceCall lt TResult  TService gt  this TService client  Func lt TService  TResult gt  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

User · Answer

I have my own wrapper for a channel which implements Dispose as follows   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                This seems to work well and allows a using block to be used

User · Answer

I ve finally found some solid steps towards a clean solution to this problem      This custom tool extends WCFProxyGenerator to provide an exception handling proxy  It generates an additional proxy called ExceptionHandlingProxy lt T gt  which inherits ExceptionHandlingProxyBase lt T gt  - 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 lt T gt  or ExceptionHandlingProxy lt T gt  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 has a project called Exception Handling WCF Proxy Generator  It basically installs a new custom tool to Visual nbsp Studio nbsp 2008  then use this tool to generate the new service proxy  Add service reference   It has some nice functionality to deal with faulted channels  timeouts and safe disposal  There s an excellent video here called ExceptionHandlingProxyWrapper explaining exactly how this works   You can safely use the Using statement again  and if the channel is faulted on any request  TimeoutException or CommunicationException   the Wrapper will re-initialize the faulted channel and retry the query  If that fails then it will call the Abort   command and dispose of the proxy and rethrow the Exception  If the service throws a FaultException code it will stop executing  and the proxy will be aborted safely throwing the correct exception as expected

User · Answer

For those interested  here s a VB NET translation of the accepted answer  below   I ve refined it a bit for brevity  combining some of the tips by others in this thread   I admit it s off-topic for the originating tags  C    but as I wasn t able to find a VB NET version of this fine solution I assume that others will be looking as well  The Lambda translation can be a bit tricky  so I d like to save someone the trouble   Note that this particular implementation provides the ability to configure the ServiceEndpoint at runtime     Code   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   Usage   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

User · Answer

What is this   This is the CW version of the accepted answer but with  what I consider complete  Exception handling included   The accepted answer references this website that is no longer around   To save you trouble  I am including the most relevant parts here   In addition  I modified it slightly to include exception retry handling to handle those pesky network timeouts   Simple WCF Client Usage  Once you generate your client side proxy  this is all you need to implement it   Service lt IOrderService gt  Use orderService  gt      orderService PlaceOrder request         ServiceDelegate cs  Add this file to your solution   No changes are needed to this file  unless you want to alter the number of retries or what exceptions you want to handle   public delegate void UseServiceDelegate lt T gt  T proxy    public static class Service lt T gt        public static ChannelFactory lt T gt   channelFactory   new ChannelFactory lt T gt             public static void Use UseServiceDelegate lt T gt  codeBlock                IClientChannel proxy    IClientChannel  channelFactory CreateChannel            bool success   false           Exception mostRecentEx   null         int millsecondsToSleep   1000          for int i 0  i lt 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  amp  amp  mostRecentEx    null                        proxy Abort               throw new Exception  WCF call failed after 5 retries    mostRecentEx                        PS  I ve made this post a community wiki   I won t collect  points  from this answer  but prefer you upvote it if you agree with the implementation  or edit it to make it better

User · Answer

The following helper allows to call void and non-void methods  Usage   var calculator   new WcfInvoker lt CalculatorClient gt       gt  new CalculatorClient     var sum   calculator Invoke c   gt  c Sum 42  42    calculator Invoke c   gt  c RebootComputer       The class itself is   public class WcfInvoker lt TService gt      where TService   ICommunicationObject       readonly Func lt TService gt   clientFactory       public WcfInvoker Func lt TService gt  clientFactory                 clientFactory   clientFactory             public T Invoke lt T gt  Func lt TService  T gt  action                var client    clientFactory            try                       var result   action client               client Close                return result                    catch                       client Abort                throw                       public void Invoke Action lt TService gt  action                Invoke lt object gt  client   gt                        action client               return null

User · Answer

Actually  although I blogged  see Luke s answer   I think this is better than my IDisposable wrapper  Typical code   Service lt IOrderService gt  Use orderService  gt      orderService PlaceOrder request             edit per comments   Since Use returns void  the easiest way to handle return values is via a captured variable   int newOrderId   0     need a value for definite assignment Service lt IOrderService gt  Use orderService  gt          newOrderId   orderService PlaceOrder request         Console WriteLine newOrderId      should be updated

User · Answer

Our system architecture often uses the Unity IoC framework to create instances of ClientBase so there s no sure way to enforce that the other developers even use using   blocks  In order to make it as fool-proof as possible  I made this custom class that extends ClientBase  and handles closing down the channel on dispose  or on finalize in case someone doesn t explicitly dispose of the Unity created instance   There is also stuff that needed to be done in the constructor to set up the channel for custom credentials and stuff  so that s in here too     public abstract class PFServer2ServerClientBase lt TChannel gt    ClientBase lt TChannel gt   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                      Then a client can simply   internal class TestClient   PFServer2ServerClientBase lt ITest gt   ITest       public string TestMethod int value                return base Channel TestMethod value             And the caller can do any of these   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 lt ITest gt                           return t TestMethod value

User · Answer

This is Microsoft s recommended way to handle WCF client calls   For more detail see  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        Additional information So many people seem to be asking this question on WCF that Microsoft even created a dedicated sample to demonstrate how to handle exceptions   c  WF WCF Samples WCF Basic Client ExpectedExceptions CS client  Download the sample  C  or  VB    Considering that there are so many issues involving the using statement   heated   Internal discussions and threads on this issue  I m not going to waste my time trying to become a code cowboy and find a cleaner way   I ll just suck it up  and implement WCF clients this verbose  yet trusted  way for my server applications     Optional Additional Failures to catch  Many exceptions derive from CommunicationException and I don t think most of those exceptions should be retried   I drudged through each exception on MSDN and found a short list of retry-able exceptions  in addition to TimeOutException above   Do let me know if I missed an exception that should be retried        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     Admittedly  this is a bit of mundane code to write   I currently prefer this answer  and don t see any  hacks  in that code that may cause issues down the road

User · Answer

Marc Gravell  Wouldn t it be OK to use this   public static TResult Using lt T  TResult gt  this T client  Func lt T  TResult gt  work          where T   ICommunicationObject       try               var result   work client            client Close             return result            catch  Exception e                client Abort             throw            Or  the same thing  Func lt T  TResult gt   in case of Service lt IOrderService gt  Use  These would make returning variables easier

User · Answer

If you don t need IoC or are using an autogenerated client  Service Reference   then you can simple use a wrapper to manage the closing and let the GC take the clientbase when it is in a safe state that will not throw any exception  The GC will call Dispose in serviceclient  and this will call Close  Since it is alread closed  it cannot cause any damage  I am using this without problems in production code   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                      Then when you are accessing the server  you create the client and use using in the autodisconect   var Ws   new ServiceClient  netTcpEndPointName    using  new AutoCloseWcf Ws          Ws Open         Ws Test

User · Answer

Summary  Using the techniques described in this answer one can consume a WCF service in a using block with the following syntax   var channelFactory   new ChannelFactory lt IMyService gt        var serviceHelper   new ServiceHelper lt IMyService gt  channelFactory   var proxy   serviceHelper CreateChannel    using  proxy as IDisposable        proxy DoWork        You can of course adapt this even further to achieve a more concise programming model specific to your situation - but the point is that we can create an implementation of IMyService reprenting the channel which correctly implements the disposable pattern     Details  All the answers given thus far address the problem of getting around the  bug  in the WCF Channel implemention of IDisposable   The answer that seems to offer the most concise programming model  allowing you to use the using block to dispose on unmanaged resources  is this one - where the proxy is modifed to implement IDisposable with a bug-free implementation   The problem with this approach is maintainability - we have to re-implement this functionality for ever proxy we use   On a variation of this answer we will see how we can use composition rather than inheritance to make this technique generic   First Attempt  There seem to various implementations for the IDisposable implementation  but for sake of argument we will use an adaption of that used by the 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              Armed with the above classes we can now write  public class ServiceHelper       private readonly ChannelFactory lt IMyService gt   channelFactory       public ServiceHelper ChannelFactory lt IMyService gt  channelFactory                  channelFactory   channelFactory             public IMyService CreateChannel                 var channel    channelFactory CreateChannel            var channelDisposer   new ProxyDisposer channel as IClientChannel           return new ProxyWrapper channel  channelDisposer             This allows us to consume our service using the using block   ServiceHelper serviceHelper        var proxy   serviceHelper CreateChannel    using  proxy as IDisposable        proxy DoWork        Making this generic  All we have done so far is to reformulate Tomas  solution   What prevents this code from being generic is the fact that ProxyWrapper class has to be re-implemented for every service contract we want   We will now look at a class that allows us to create this type dynamically using IL   public class ServiceHelper lt T gt        private readonly ChannelFactory lt T gt   channelFactory       private static readonly Func lt T  IDisposable  T gt   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 lt T  IDisposable  T gt  channelCreatorMethod CreateDelegate typeof Func lt T  IDisposable  T gt                 public ServiceHelper ChannelFactory lt T gt  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   gt  tf              tf   gt  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  lt   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   gt  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  lt  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              With our new helper class we can now write  var channelFactory   new ChannelFactory lt IMyService gt        var serviceHelper   new ServiceHelper lt IMyService gt  channelFactory   var proxy   serviceHelper CreateChannel    using  proxy as IDisposable        proxy DoWork        Note that you could also use the same technique  with slight modifications  for auto-generated clients inheriting for ClientBase lt  gt   instead of using ChannelFactory lt  gt    or if you want to use a different implementation of IDisposable to close your channel

User · Answer

Override the client s Dispose   without the need to generate a proxy class based on ClientBase  also without the need to manage channel creation and caching    Note that WcfClient is not an ABSTRACT class and is based on ClientBase      No need for a generated proxy class   using  WcfClient lt IOrderService gt  orderService   new WcfClient lt IOrderService gt               results   orderService GetProxy   PlaceOrder input        public class WcfClient lt TService gt    ClientBase lt TService gt   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

User · Answer

I like this way of closing connection   var client   new ProxyClient    try               client Close      finally       if client State    CommunicationState Closed          client Abort

User · Answer

I have written a simple base class that handles this  It s available as a NuGet package and it s quite easy to use     MemberServiceClient is the class generated by SvcUtil public class MemberServiceManager   ServiceClientBase lt MemberServiceClient gt        public User GetUser int userId                return PerformServiceOperation client   gt  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   gt  c GetUser userId   out user

User · Answer

Based on answers by Marc Gravell  MichaelGG  and Matt Davis  our developers came up with the following   public static class UsingServiceClient       public static void Do lt TClient gt  TClient client  Action lt TClient gt  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                                      Example of use   string result   string Empty   UsingServiceClient Do      new MyServiceClient        client   gt      result   client GetServiceResult parameters      It s as close to the  using  syntax as possible  you don t have to return a dummy value when calling a void method  and you can make multiple calls to the service  and return multiple values  without having to use tuples   Also  you can use this with ClientBase lt T gt  descendants instead of ChannelFactory if desired   The extension method is exposed if a developer wants to manually dispose of a proxy channel instead

User · Answer

You could also use a DynamicProxy to extend the Dispose   method  This way you could do something like   using  var wrapperdProxy   new Proxy lt yourProxy gt             Do whatever and dispose of Proxy lt yourProxy gt  will be called and work properly

User · Answer

My method of doing this has been to create an inherited class that explicitly implements IDisposable  This is useful for folks who use the gui to add the service reference   Add Service Reference    I just drop this class in the project making the service reference and use it instead of the default client   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                       Note  This is just a simple implementation of dispose  you can implement more complex dispose logic if you like   You can then replace all your calls made with the regular service client with the safe clients  like this   using  MyServiceClientSafe client   new MyServiceClientSafe          var result   client MyServiceMethod        I like this solution as it does not require me to have access to the Interface definitions and I can use the using statement as I would expect while allowing my code to look more or less the same    You will still need to handle the exceptions which can be thrown as pointed out in other comments in this thread

User · Answer

Given a choice between the solution advocated by IServiceOriented com and the solution advocated by David Barret s blog  I prefer the simplicity offered by overriding the client s Dispose   method   This allows me to continue to use the using   statement as one would expect with a disposable object   However  as  Brian pointed out  this solution contains a race condition in that the State might not be faulted when it is checked but could be by the time Close   is called  in which case the CommunicationException still occurs   So  to get around this  I ve employed a solution that mixes the best of both worlds   void IDisposable Dispose         bool success   false      try                if  State    CommunicationState Faulted                         Close                success   true                       finally                if   success               Abort

User · Answer

I referred few answers on this post and customized it as per my needs    I wanted the ability to do something with WCF client before using it so the DoSomethingWithClient   method   public interface IServiceClientFactory lt T gt        T DoSomethingWithClient      public partial class ServiceClient   IServiceClientFactory lt ServiceClient gt        public ServiceClient DoSomethingWithClient                 var client   this             do somthing here as set client credentials  etc            client ClientCredentials                 return client            Here is the helper class    public static class Service lt TClient gt      where TClient   class  ICommunicationObject  IServiceClientFactory lt TClient gt   new         public static TReturn Use lt TReturn gt  Func lt TClient  TReturn gt  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  amp  amp  client    null                                client Abort                                      And I can use it as    string data   Service lt ServiceClient gt  Use x   gt  x GetData 7

[c#] What is the best workaround for the WCF client `using` block issue?

Examples related to c#

Examples related to vb.net

Examples related to wcf

Examples related to using

Examples related to wcf-client