WCF代理+ DI (尼尼姆)+ IDisposable

Question

我有一个MVC4应用程序，它调用一些WCF服务。

我读到了用“使用”语法(读这个..。)处理WCF代理时可能出现的一些问题。我正试图在我的解决方案(...and现在这个)中正确地实现WCF代理处理。

标准请求通过应用程序中的以下层运行：

MVC控制器>“主外观”>“次要外观”> Controller (遗留代码)。不是我的错)

我正在使用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服务，但是如果不进行大规模重构，我想不出一种方法。也许尼尼特会来救你..。

任何帮助都是非常感谢的。

谢谢。

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 (我想这就是传递给您的小外观的东西)，然后调用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();
     }

}