Entsorgen Playlist erstellt von WCF Channel

Question

Ich suche eine saubere Art und Weise die zu haben Channel Kanäle für mich schaffen mit der Fähigkeit, sie nach Gebrauch zu entsorgen.
Das ist, was ich habe:

public class ClientFactory : IClientFactory 
{ 
    private const string endpointName = "IMyService"; 
    private readonly ChannelFactory<IMyService> _factory; 

    public ClientFactory() 
    { 
     _factory = new ChannelFactory<IMyService>(endpointName); 
    } 

    public Client<IMyService> GetClient() 
    {  
     IMyService channel = _factory.CreateChannel(); 
     return new Client<IMyService>(channel); 
    } 
} 

public class Client<T> : IDisposable 
{ 
    public T Channel { get; private set; } 

    public Client(T channel) 
    { 
     if (channel == null) 
      throw new ArgumentException("channel"); 

     Channel = channel; 
    } 

    public void Dispose() 
    { 
     (Channel as IDisposable).Dispose(); 
    } 
} 

//usage 
using (var client = _serviceFactory.GetClient()) 
{ 
    client.Channel.DoStuff(); 
} 

Ist das eine gute Lösung?
Gibt es sauberere Möglichkeiten, dies zu tun?

Answer 1

Nein, es gibt keine sauberere Möglichkeit, den Kanal zu umhüllen.

Alternativ können Sie auch Action/Func verwenden. Es ist nicht sauberer, könnte aber für Ihre Anwendung besser geeignet sein.

Dies ist, wie ich es tun:

internal class WrappedClient<T, TResult> : IDisposable 
{ 
    private readonly ChannelFactory<T> _factory; 
    private readonly object _channelLock = new object(); 
    private T _wrappedChannel; 

    public WrappedClient(ChannelFactory<T> factory) 
    { 
     _factory = factory; 
    } 

    protected T WrappedChannel 
    { 
     get 
     { 
      lock (_channelLock) 
      { 
       if (!Equals(_wrappedChannel, default(T))) 
       { 
        var state = ((ICommunicationObject)_wrappedChannel).State; 
        if (state == CommunicationState.Faulted) 
        { 
         // channel has been faulted, we want to create a new one so clear it 
         _wrappedChannel = default(T); 
        } 
       } 

       if (Equals(_wrappedChannel, default(T))) 
       { 
        _wrappedChannel = _factory.CreateChannel(); 
       } 
      } 

      return _wrappedChannel; 
     } 
    } 

    public TResult Invoke(Func<T, TResult> func) 
    { 
     try 
     { 
      return func(WrappedChannel); 
     } 
     catch (FaultException) 
     { 
      throw; 
     } 
     catch (CommunicationException) 
     { 
      // maybe retry works 
      return func(WrappedChannel); 
     } 
    } 

    protected virtual void Dispose(bool disposing) 
    { 
     if (!disposing || 
      Equals(_wrappedChannel, default(T))) 
      return; 

     var channel = _wrappedChannel as ICommunicationObject; 
     _wrappedChannel = default(T); 
     try 
     { 
      channel.Close(); 
     } 
     catch (CommunicationException) 
     { 
      channel.Abort(); 
     } 
     catch (TimeoutException) 
     { 
      channel.Abort(); 
     } 
    } 

    public void Dispose() 
    { 
     Dispose(true); 
    } 
} 

Dann nutzen Sie den Service wie

client.Invoke(channel => channel.DoStuff()) 

Answer 2

so etwas tun:

public interface IMyServiceClient : IMyService, ICommunicationObject { } 

Wenn Sie einen Kanal für das schaffen, können Sie es entsorgen.