Appel du service WCF à l'aide de la méthode d'extension

Question

J'ai écrit une méthode d'extension à utiliser avec les services WCF qui conserve toute la logique de gestion des exceptions et des exceptions en un seul endroit. La méthode est la suivante:

public static TResult CallMethod<TChannel, TResult>(
    this ClientBase<TChannel> proxy, 
    Func<TResult> func) where TChannel : class 
{ 
    proxy.ThrowIfNull("proxy"); 
    func.ThrowIfNull("func"); 

    try 
    { 
     // set client credentials 
     return func(); 
    } 
    finally 
    { 
     if (proxy != null) 
     { 
      try 
      { 
       if (proxy.State != CommunicationState.Faulted) 
       { 
        proxy.Close(); 
       } 
       else 
       { 
        proxy.Abort(); 
       } 
      } 
      catch (CommunicationException) 
      { 
       proxy.Abort(); 
      } 
      catch (TimeoutException) 
      { 
       proxy.Abort(); 
      } 
      catch (Exception) 
      { 
       proxy.Abort(); 
       throw; 
      } 
     } 
    } 
} 

La méthode sera utilisée comme ceci:

public int CreateBusinessObject(BusinessObject item) 
{ 
    MyServiceClient proxy = new MyServiceClient(); 
    return proxy.CallMethod(() => proxy.CreateBusinessObject(item)); 
} 

Ma question est de savoir si ce serait mieux comme méthode statique qui crée le proxy de service? Je suis un peu inquiet de ma mise en œuvre actuelle. La construction du proxy devrait-elle être dans le try/catch? Ma compréhension actuelle est que si le constructeur échoue, il n'y a rien à se débarrasser de toute façon.

Answer 1

Si le constructeur échoue, l'objet entier est dans un état non valide. Vous ne devriez pas vous inquiéter de disposer dans ce cas.

Un bon test pour c'est ce qui se passerait lorsque vous exécutez la commande suivante:

class Program 
{ 
    static void Main(string[] args) 
    { 
     using (new TestClass()) 
     { 
      Console.WriteLine("In using"); 
     } 
    } 

    class TestClass : IDisposable 
    { 
     public TestClass() 
     { 
      throw new Exception(); 
     } 

     public void Dispose() 
     { 
      Console.WriteLine("Disposed"); 
     } 
    } 
} 

Le résultat est que le Disposing ne s'atteint. C'est ce qui arrive quand le constructeur échoue.