HEGII.ft.mes.plc/PCLCommunication/Proxy/WCFProxy.cs


using System;
using System.ServiceModel;

//using Curtain.WCF.Contract;

namespace Curtain.WCF.Proxy
{
    /// <summary>
    /// WCF服务代理基类
    /// </summary>
    public abstract class WCFProxy<TChannel> : IDisposable//, IWCFProxy
        where TChannel : class//, IWCFContract
    {
        #region 常量
        #endregion

        #region 成员变量
        /// <summary>
        /// 终结点的配置名称
        /// </summary>
        private string _endpointName = null;
        private string _serviceName = null;
        /// <summary>
        /// WCF通道工厂
        /// </summary>
        private ChannelFactory<TChannel> _channelFactory = null;
        /// <summary>
        /// WCF代理配置
        /// </summary>
        private WCFProxySetting _setting = null;
        /// <summary>
        /// WCF代理配置版本
        /// </summary>
        private int _settingVersion = 0;
        #endregion

        #region 构造
        /// <summary>
        /// WCF服务代理基类
        /// </summary>
        /// <param name="endpointName"></param>
        /// <param name="settingName"></param>
        /// <param name="serviceName"></param>
        protected WCFProxy(string endpointName, string settingName, string serviceName)
        {
            if (string.IsNullOrWhiteSpace(endpointName))
            {
                throw new ArgumentNullException("endpointName");
            }

            this._endpointName = endpointName;
            this._serviceName = serviceName;
            this._setting = WCFProxySetting.CreateSetting(settingName);
        }

        /// <summary>
        /// WCF服务代理基类
        /// </summary>
        /// <param name="endpointName"></param>
        /// <param name="setting"></param>
        protected WCFProxy(string endpointName, WCFProxySetting setting, string serviceName)
        {
            if (string.IsNullOrWhiteSpace(endpointName))
            {
                throw new ArgumentNullException("endpointName");
            }

            this._endpointName = endpointName;
            this._serviceName = serviceName;
            this._setting = (setting == null ? WCFProxySetting.DefaultSetting : setting);
        }
        #endregion

        #region 属性
        public string EndpointName
        {
            get
            {
                return this._endpointName;
            }
        }
        public string ServiceName
        {
            get
            {
                return this._serviceName;
            }
        }
        /// <summary>
        /// WCF代理配置
        /// </summary>
        public WCFProxySetting ProxySetting
        {
            get
            {
                return this._setting;
            }
        }

        /// <summary>
        /// 信道工厂
        /// </summary>
        public ChannelFactory<TChannel> ChannelFactory
        {
            get
            {
                return this._channelFactory;
            }
        }
        #endregion

        #region 公有方法
        /// <summary>
        /// 执行
        /// </summary>
        /// <param name="serviceInvocation"></param>
        /// <param name="timeout">超时（分钟）</param>
        public virtual void Invoke(Action<TChannel> serviceInvocation, double timeout = 0)
        {
            TChannel channel = null;//default(TChannel);
            IContextChannel contextChannel = null;
            string methodName = serviceInvocation.Method.ToString();
            try
            {
                if (this._setting.Type == 1)
                {
                    channel = this.GetServerInstance();
                }
                else
                {
                    this.OpenChannelFactory();

                    channel = this._channelFactory.CreateChannel();
                    contextChannel = channel as IContextChannel;

                    if (contextChannel != null)
                    {
                        if (timeout > WCFProxySetting.OPERATION_TIMEOUT_MAX)
                        {
                            timeout = WCFProxySetting.OPERATION_TIMEOUT_MAX;
                        }
                        if (timeout > 0)
                        {
                            contextChannel.OperationTimeout = TimeSpan.FromMinutes(timeout);
                        }
                    }
                }

                serviceInvocation(channel);
                this.InvokeDone<object>(methodName, null, true);
            }
            catch (Exception ex)
            {
                Exception newEx = this.InvokeException(methodName, ex);
                if (newEx == null)
                {
                    return;
                }
                throw newEx;
            }
            finally
            {
                if (contextChannel != null)
                {
                    try
                    {
                        contextChannel.Close();
                    }
                    catch
                    {
                        contextChannel.Abort();
                    }
                }
            }
        }

        /// <summary>
        /// 执行
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="serviceInvocation"></param>
        /// <param name="timeout">超时（分钟）</param>
        /// <returns></returns>
        public virtual TResult Invoke<TResult>(Func<TChannel, TResult> serviceInvocation,
            double timeout = 0)
        {
            TChannel channel = null;// default(TChannel);
            IContextChannel contextChannel = null;
            string methodName = serviceInvocation.Method.ToString();
            try
            {
                //if (this._setting.Type == 1)
                //{
                //    channel = this.GetServerInstance();
                //}
                ////else
                //if(channel == null)
                {
                    this.OpenChannelFactory();

                    channel = this._channelFactory.CreateChannel();
                    contextChannel = channel as IContextChannel;

                    if (contextChannel != null)
                    {
                        if (timeout > WCFProxySetting.OPERATION_TIMEOUT_MAX)
                        {
                            timeout = WCFProxySetting.OPERATION_TIMEOUT_MAX;
                        }
                        if (timeout > 0)
                        {
                            contextChannel.OperationTimeout = TimeSpan.FromMinutes(timeout);
                        }
                    }
                }

                TResult result = serviceInvocation(channel);
                result = this.InvokeDone<TResult>(methodName, result);
                return result;
            }
            catch (Exception ex)
            {
                Exception newEx = this.InvokeException(methodName, ex);
                if (newEx == null)
                {
                    return default(TResult);
                }
                throw newEx;
            }
            finally
            {
                if (contextChannel != null)
                {
                    try
                    {
                        contextChannel.Close();
                    }
                    catch
                    {
                        contextChannel.Abort();
                    }
                }
            }
        }

        /// <summary>
        /// 关闭通道工厂
        /// </summary>
        public void CloseChannelFactory()
        {
            try
            {
                this._channelFactory.Close();
            }
            catch
            {
                this._channelFactory.Abort();
            }
            finally
            {
                this._channelFactory = null;
            }
        }

        /// <summary>
        /// 释放分配的资源
        /// </summary>
        public void Dispose()
        {
            this._setting = null;
            this.CloseChannelFactory();
        }
        #endregion

        #region 保护方法

        protected virtual TChannel GetServerInstance()
        {
            //throw new NotImplementedException();
            return null;
        }

        /// <summary>
        /// 异常处理
        /// 1.写日志
        /// 2.客户端连接异常处理
        /// 3.服务端异常处理
        /// </summary>
        /// <param name="cre"></param>
        /// <param name="sre"></param>
        /// <param name="ex"></param>
        /// <returns>抛出未处理异常</returns>
        protected virtual Exception InvokeException(string methodName, Exception ex)
        {
            return ex;
        }

        /// <summary>
        /// 请求被处理后
        /// 1.如果服务端异常已处理，写日志，提示消息等处理。
        /// </summary>
        /// <param name="result"></param>
        protected virtual TResult InvokeDone<TResult>(string methodName, TResult result, bool isOneWay = false)
        {
            return result;
        }

        #endregion

        #region 私有方法
        /// <summary>
        /// 打开通道工厂
        /// </summary>
        protected void OpenChannelFactory()
        {
            lock (this)
            {
                if (this._channelFactory != null &&
                    this._settingVersion != this._setting.Version)
                {
                    this.CloseChannelFactory();
                }

                if (this._channelFactory == null)
                {
                    this._settingVersion = this._setting.Version;
                    EndpointAddress remoteAddress = new EndpointAddress(this._setting.GetEndpointAddress(this._serviceName));
                    this._channelFactory = new ChannelFactory<TChannel>(this._endpointName, remoteAddress);
                    this._channelFactory.Open();
                }
            }
        }
        #endregion
    }
}