WCF代理+ DI（Ninject）+ IDisposable

Question

我有一个调用某些WCF服务的MVC4应用程序。

我阅读了一些有关使用“使用”语法处理WCF代理时可能发生的问题的信息（请阅读此... ）。 我正在尝试在我的解决方案中正确实现WCF代理处理（ 现在是... ）。

标准请求贯穿应用程序的以下各层：

MVC控制器>“主外观”>“次要外观”> WCF代理 （旧版代码。不是我的错）

我正在使用Ninject 3.2.2.0将依赖项自动注入这些层中。 例如：

控制器：

public class HomeController : Controller
{
    private readonly SomeMainFacade _someMainFacade;

    public HomeController(SomeMainFacade someMainFacade)
    {
        _someMainFacade = someMainFacade;
    }
    ...
}

“主立面”：

public class SomeMainFacade 
{
    private readonly MinorFacade1 _minorFacade1;
    private readonly MinorFacade2 _minorFacade2;

     public SomeMainFacade (
        MinorFacade1 minorFacade1,
        MinorFacade2 minorFacade2
       ){
             _minorFacade1 = minorFacade1;
             _minorFacade2= minorFacade2;
        }
        ...
 }

“小门面”

public class MinorFacade1
{
    private readonly IWCFService _wcfServiceClient;

    public MinorFacade1(IWCFService wcfServiceClient)
    {
        _wcfServiceClient= wcfServiceClient;
    }
    ...
}

我想正确处理“次要外观”中使用的WCF服务，但是如果不进行大量重构，我想不出这种方法。 也许Ninject来救援了...

任何帮助表示赞赏。

谢谢。

Answer 1

这是我很久以前在一个遥远的星系中写的一类：

/// <summary>
/// 
/// </summary>
/// <typeparam name="T"></typeparam>
public class RemotingClient<T> : IDisposable
{
    private bool _disposed;

    private readonly ChannelFactory<T> _factory;


    /// <summary>
    /// 
    /// </summary>
    public event OnCloseChannel ChannelClosed;

    public event OnFaultedChannel ChannelFaulted;

    /// <summary>
    /// 
    /// </summary>
    public delegate void OnCloseChannel();

    public delegate void OnFaultedChannel();

    /// <summary>
    /// 
    /// </summary>
    /// <param name="factory"></param>
    public RemotingClient(ChannelFactory<T> factory)
        : this(factory, SynchronizationContext.Current)
    {
    }

    private void OnClose(object sender, EventArgs e)
    {
        if (null != ChannelClosed)
            ChannelClosed();
    }

    private void OnFaulted(object sender, EventArgs e)
    {
        if (null != ChannelFaulted)
            ChannelFaulted();
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="factory"></param>
    /// <param name="context"></param>
    public RemotingClient(ChannelFactory<T> factory, SynchronizationContext context)
    {
        Context = context;
        _factory = factory;
        CreateNewChannel();
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="uiCallback"></param>
    public void PostToContext(SendOrPostCallback uiCallback)
    {

        Context.Post(uiCallback, null);
    }

    public void CreateNewChannel()
    {
        Channel = _factory.CreateChannel();

        ICommunicationObject c = Channel as ICommunicationObject;

        if (null == c)
            throw new ArgumentException(
                typeof(T) + " Can not be used as an ICommunicationObject");

        c.Closed += OnClose;
        c.Faulted += OnFaulted;
        c.Open();
    }

    /// <summary>
    /// 
    /// </summary>
    public SynchronizationContext Context
    { get; private set; }

    /// <summary>
    /// 
    /// </summary>
    public T Channel
    { get; set; }

    public CommunicationState ChannelState
    {
        get
        {
            ICommunicationObject c = (ICommunicationObject)Channel;
            return c.State;
        }
    }

    #region IDisposable Members
    /// <summary>
    /// 
    /// </summary>
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public void Dispose(bool disposing)
    {
        if (!this._disposed)
        {
            if (disposing)
                Close();

            this._disposed = true;
        }

    }

    public void Close()
    {
        ICommunicationObject c = Channel as ICommunicationObject;

        if (c.State == CommunicationState.Faulted)
            c.Abort();

        c.Close();

    }

    #endregion
}

然后基本上在某个地方创建一个静态ChannelFactory（我想这将传递给您的minorfacade），然后调用RemotingClient。 像这样：

public class MinorFacade1
{
    private static ChannelFactory<IMyServiceContract> MyFactory{ get; set; }

    public MinorFacade1(ChannelFactory<IMyServiceContract> factory)
    {
        MyFactory = factory;
     }


    public void DoSomeAwesomeWcfCall()
    {
       using(RemotingClient<IMyServiceContract> proxy = new RemotingClient<IMyServiceContract>(MyFactory)
            proxy.Channel.ThisIsAnAwesomeWcfCall();
     }

}