Entsorgen Kanal erstellt von WCF ChannelFactory

Ich bin auf der Suche nach einem sauber die ChannelFactory erstellen Kanäle für mich mit dem Fähigkeit zu entsorgen nach dem Gebrauch.

Dies 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 Reiniger Möglichkeiten, dies zu tun?

Nicht über den Kanal, wie. Verwenden: try { Kanal.Close(); } catch (CommunicationException) { channel.Abort(); } catch (TimeoutException) { channel.Abort(); }
Wie kommt das? Nicht Entsorgung Kanal das gleiche tun für mich?
Entsorgen Sie werden in der Nähe nennen. In der Nähe auslösen könnte. Schreiben Sie alle Ihre mit Aussagen wie: try { using (...) { ... } } catch (CommunicationException) { } oder verwenden Sie mein Muster oben.
Thx, wusste das nicht.

InformationsquelleAutor David | 2013-03-05

.net c#channelfactory wcf

Nein, es gibt keine sauberere Möglichkeit zum wickeln des Kanals.

Andere Weise, die Sie tun können, ist die Nutzung von Action/Func, statt. Es ist nicht sauberer, aber möglicherweise besser geeignet für Ihre Anwendung.

Dies ist, wie ich es mache:

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

Ich denke, ich werde halten die Fabrik, wie es ist, mit der Ausnahme von euren Vorschlag in die Kommentare.
wir danken Ihr für die code-Bereinigung. Ich entfernte die .? was ich davon ausgehen, war ein misstake.

InformationsquelleAutor adrianm

2

Etwas zu tun:
```
public interface IMyServiceClient : IMyService, ICommunicationObject { }
```
Wenn Sie ein Kanal für das, können Sie es entsorgen.
- Das wäre eine neue Schnittstelle pro service obwohl. Ich möchte einen generischen, wiederverwendbaren Ansatz.
- Naja, es ist nur ein beschreibendes interface - es ist keine weitere Implementierung notwendig. Sie nicht bekommen wird es kürzer, ich denke
InformationsquelleAutor TGlatzer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.