WCF实现长连接

class AliveConnection where T : System.ServiceModel.ICommunicationObject, new()
    {
        private string _endpointCOnfigName= string.Empty;
        private T _instance = default(T);
        /// 

        /// 正在执行其他过程时，设置为正忙。执行完成后闲置
        /// 连接出错后，正在重新连接创建时设置为正忙，解除正忙状态有俩种情况：
        /// 1.第一次重建连接成功后；
        /// 2.在线程中重试成功后；
        /// 
        public bool IsBusy { get; set; }

        internal AliveConnection(string endpointConfigName)
        {
            if (string.IsNullOrEmpty(endpointConfigName.Trim())) throw new ArgumentException("终结点不能配置为空。");
            _endpointConfigName = endpointConfigName;
            //_instance = CreateConnection();
        }

        internal bool Execute(Action expression)
        {
            try
            {
                Open();
                expression(_instance);
                return true;
            }
            catch (System.ServiceModel.CommunicationException e)
            {
                return false;
            }
        }

        internal bool Execute(Func expression,out TResult result)
        {
            result = default(TResult);
            try
            {
                Open();
                result = expression(_instance);
                return true;
            }
            catch (System.ServiceModel.CommunicationException e)
            {
                return false;
            }
        }

        private void Open()
        {
            if (_instance == null)//使用时才创建
            {
                _instance = CreateConnection();
                _instance.Faulted += Faulted;
            }
            if (_instance.State != System.ServiceModel.CommunicationState.Opened)
                _instance.Open();
        }

        private void Faulted(object sender, EventArgs e)
        {
            lock (_instance)
            {
                IsBusy = true;
                //失败后锁住并重新建立连接
                _instance = CreateConnection();
            }
        }

        private T CreateConnection()
        {
            try
            {
                var instance = (T)Activator.CreateInstance(typeof(T), _endpointConfigName);
                IsBusy = false;
                return instance;
            }
            catch (Exception e)
            {
                IsBusy = true;
                RetryWhenFailed();
                throw new Exception("创建连接失败，请检测终结点配置和服务。", e);
            }
        }
        //创建一个线程来不间断重试创建连接
        private void RetryWhenFailed()
        {
            int retryTimes = 0;
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    //如果抛出异常，表示创建失败，继续重试，如果睡眠时间大于60秒，则睡眠时间不再增加
                    try
                    {
                        retryTimes++;
                        _instance = (T)Activator.CreateInstance(typeof(T), _endpointConfigName);
                        IsBusy = false;
                        break;
                    }
                    catch
                    {
                        int sleepMilliOnSeconds= retryTimes * 5 * 1000;
                        sleepMillionSeconds = sleepMillionSeconds > 60 * 1000 ? 60 * 1000 : sleepMillionSeconds;
                        System.Threading.Thread.Sleep(sleepMillionSeconds);
                        continue;
                    }
                }
            });
        }
    }

 /// 

    /// WCF长连接容器
    /// 
    /// 待创建的WCF服务类型
    public class AliveConnectionContainer
        where T : System.ServiceModel.ICommunicationObject, new()
    {
        #region fields
        private List> _cOnnections= null;//所有连接
        private int _currentCOnnectionIndex= 0;//当前使用的连接的索引
        #endregion

        #region Octor
        /// 

        /// 通过终结点配置名称，创建长连接。如果终结点数不等于连接数，则轮询跟节点配置列表，最终创建达到连接数的连接。
        /// 
        /// 需要创建的长连接数
        /// 所有的终结点配置名称，对应配置节点里bind的name
        /// 如果终结点配置为空，则抛出异常,如果创建失败，也会抛出异常
        public AliveConnectionContainer(int maxConnection, params string[] endpointConfigNames)
        {
            _connections = new List>(maxConnection);

            int tmpIndex = 0;
            for (int index = 0; index )
            {
                if (tmpIndex >= endpointConfigNames.Count()) tmpIndex = 0;
                _connections.Add(new AliveConnection(endpointConfigNames[tmpIndex]));
            }
        }
        #endregion

        #region public method
        /// 

        /// 执行服务调用,会一直轮询执行直到执行成功
        /// 
        /// 需要调用的处理方法
        public void Execute(Action expression)
        {
            Func<bool> executeExpression = () => Instance.Execute(expression);
            Execute(executeExpression);
        }    
        /// 

        /// 执行服务调用,会一直轮询执行直到执行成功
        /// 
        /// 需要调用的处理方法
        public TResult Execute(Func expression)
        {
            TResult result = default(TResult);
            Func<bool> executeExpression = () => Instance.Execute(expression,out result);
            Execute(executeExpression);
            return result;
        }

        private void Execute(Func<bool> expression)
        {
            bool success = false;
            int failedCount = 0;
            try
            {
                while (true)
                {
                    success = expression();
                    if (!success) failedCount++;
                    else break;

                    if (failedCount >= _connections.Count) throw new Exception("没有可用的服务,请检测服务运行状态。");
                }
            }
            catch (Exception e)
            {
                throw new Exception("执行WCF服务调用失败。", e);
            }
        }

        #endregion

        #region private method
        private AliveConnection Instance
        {
            get
            {
                if (_cOnnections== null || _connections.Count == 0) throw new Exception("没有可用的连接，请先设置连接。");
                AliveConnection result;
                while (!(result = GetInstance()).IsBusy) break;//轮询直到找到空闲的连接
                return result;
            }
        }

        private AliveConnection GetInstance()
        {
            if (_currentConnectionIndex >= _connections.Count) _currentCOnnectionIndex= 0;
            return _connections[_currentConnectionIndex++];
        }
        #endregion
    }

/// 

    /// 长连接服务的管理类
    /// 
    /// 
    /// AliveConnectionManager.Register(endpoints,10);
    /// var client = AliveConnectionManager.Resolve();
    /// List movies;
    /// client.Execute(service => movies = service.GetMovies());
    /// 
    public static class AliveConnectionManager
    {
        private static Dictionaryobject> _cOntainer= new Dictionaryobject>();
        /// 

        /// 根据输入的终结点列表，在app.config文件中查找对应的终结点，并建立连接
        /// 
        /// 要注册的WCF的服务类型
        /// 连接数
        /// 配置的终结点列表
        public static void Register(int maxConnection, params string[] endpointConfigNames)
            where T : System.ServiceModel.ICommunicationObject, new()
        {
            if (_container.ContainsKey(typeof(T))) throw new ArgumentException(string.Format("容器中已经添加过{0}的长连接服务。", typeof(T)));
            _container.Add(typeof(T), new AliveConnectionContainer(maxConnection, endpointConfigNames));
        }

        /// 

        /// 获取类型为T的长连接服务
        /// 
        /// 待获取的WCF的服务类型
        /// 对应类型为T的服务
        public static AliveConnectionContainer Resolve() where T : System.ServiceModel.ICommunicationObject, new()
        {
            Type type = typeof(T);
            if (!_container.ContainsKey(type)) throw new ArgumentException(string.Format("没有找到类型为{0}的长连接服务。", type));
            return _container[type] as AliveConnectionContainer;
        }
    }

 AliveConnectionManager.Register(endpoints,10);

var client = AliveConnectionManager.Resolve();
 List movies;
client.Execute(service => movies = service.GetMovies());