WCF客户端配置文件分离(自定义WCF客户端配置文件)

做了许许多多的WCF的开发，当自己的项目中引用越来越多的服务之后发现程序的配置文件越来越庞大，维护起这个配置文件来也就比较困难了。其实我们完全可以把这些WCF的配置分离出来到单独的文件中。这样使得服务的配置和程序的配置都很容易维护。
实现这个功能其实很简单，只需要重载一下ChannelFactory<T>里的一些方法。
这个类就是负责加载配置信息的类。下面给出我的代码：

  1/**//// <summary>
  2    /// 自定义的客户端信道(允许从自定义的配置文件中加载)
  3    /// </summary>
  4    /// <typeparam name="T"></typeparam>
  5    public class CustomClientChannel<T> : ChannelFactory<T>
  6    {
  7        string configurationPath;
  8        string endpointConfigurationName;
  9
 10        /**//// <summary>
 11        /// 构造函数
 12        /// </summary>
 13        /// <param name="configurationPath"></param>
 14        public CustomClientChannel(string configurationPath)
 15            : base(typeof(T))
 16        {
 17            this.configurationPath = configurationPath;
 18            base.InitializeEndpoint((string)null, null);
 19        }
 20
 21        /**//// <summary>
 22        /// 构造函数
 23        /// </summary>
 24        /// <param name="binding"></param>
 25        /// <param name="configurationPath"></param>
 26        public CustomClientChannel(Binding binding, string configurationPath)
 27            : this(binding, (EndpointAddress)null, configurationPath)
 28        {
 29        }
 30
 31        /**//// <summary>
 32        /// 构造函数
 33        /// </summary>
 34        /// <param name="serviceEndpoint"></param>
 35        /// <param name="configurationPath"></param>
 36        public CustomClientChannel(ServiceEndpoint serviceEndpoint, string configurationPath)
 37            : base(typeof(T))
 38        {
 39            this.configurationPath = configurationPath;
 40            base.InitializeEndpoint(serviceEndpoint);
 41        }
 42
 43        /**//// <summary>
 44        /// 构造函数
 45        /// </summary>
 46        /// <param name="endpointConfigurationName"></param>
 47        /// <param name="configurationPath"></param>
 48        public CustomClientChannel(string endpointConfigurationName, string configurationPath)
 49            : this(endpointConfigurationName, null, configurationPath)
 50        {
 51        }
 52
 53        /**//// <summary>
 54        /// 构造函数
 55        /// </summary>
 56        /// <param name="binding"></param>
 57        /// <param name="endpointAddress"></param>
 58        /// <param name="configurationPath"></param>
 59        public CustomClientChannel(Binding binding, EndpointAddress endpointAddress, string configurationPath)
 60            : base(typeof(T))
 61        {
 62            this.configurationPath = configurationPath;
 63            base.InitializeEndpoint(binding, endpointAddress);
 64        }
 65
 66        /**//// <summary>
 67        /// 构造函数
 68        /// </summary>
 69        /// <param name="binding"></param>
 70        /// <param name="remoteAddress"></param>
 71        /// <param name="configurationPath"></param>
 72        public CustomClientChannel(Binding binding, string remoteAddress, string configurationPath)
 73            : this(binding, new EndpointAddress(remoteAddress), configurationPath)
 74        {
 75        }
 76
 77        /**//// <summary>
 78        /// 构造函数
 79        /// </summary>
 80        /// <param name="endpointConfigurationName"></param>
 81        /// <param name="endpointAddress"></param>
 82        /// <param name="configurationPath"></param>
 83        public CustomClientChannel(string endpointConfigurationName, EndpointAddress endpointAddress, string configurationPath)
 84            : base(typeof(T))
 85        {
 86            this.configurationPath = configurationPath;
 87            this.endpointConfigurationName = endpointConfigurationName;
 88            base.InitializeEndpoint(endpointConfigurationName, endpointAddress);
 89        }
 90
 91        /**//// <summary>
 92        /// 从自定义配置文件中加载终结点描述
 93        /// </summary>
 94        /// <returns></returns>
 95        protected override ServiceEndpoint CreateDescription()
 96        {
 97            ServiceEndpoint serviceEndpoint = base.CreateDescription();
 98
 99            if (endpointConfigurationName != null)
                serviceEndpoint.Name = endpointConfigurationName;

            ExeConfigurationFileMap map = new ExeConfigurationFileMap();
            map.ExeConfigFilename = this.configurationPath;

            Configuration config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
            ServiceModelSectionGroup group = ServiceModelSectionGroup.GetSectionGroup(config);

            ChannelEndpointElement selectedEndpoint = null;

            foreach (ChannelEndpointElement endpoint in group.Client.Endpoints)
            {
                if (endpoint.Contract == serviceEndpoint.Contract.ConfigurationName &&
                    (this.endpointConfigurationName == null || this.endpointConfigurationName == endpoint.Name))
                {
                    selectedEndpoint = endpoint;
                    break;
                }
            }

            if (selectedEndpoint != null)
            {
                if (serviceEndpoint.Binding == null)
                {
                    serviceEndpoint.Binding = CreateBinding(selectedEndpoint.Binding, group);
                }

                if (serviceEndpoint.Address == null)
                {
                    serviceEndpoint.Address = new EndpointAddress(selectedEndpoint.Address, GetIdentity(selectedEndpoint.Identity), selectedEndpoint.Headers.Headers);
                }

                if (serviceEndpoint.Behaviors.Count == 0 && selectedEndpoint.BehaviorConfiguration != null)
                {
                    AddBehaviors(selectedEndpoint.BehaviorConfiguration, serviceEndpoint, group);
                }

                serviceEndpoint.Name = selectedEndpoint.Contract;
            }

            return serviceEndpoint;

        }

        /**//// <summary>
        /// 为所选择的终结点配置绑定
        /// </summary>
        /// <param name="bindingName"></param>
        /// <param name="group"></param>
        /// <returns></returns>
        private Binding CreateBinding(string bindingName, ServiceModelSectionGroup group)
        {
            BindingCollectionElement bindingElementCollection = group.Bindings[bindingName];
            if (bindingElementCollection.ConfiguredBindings.Count > 0)
            {
                IBindingConfigurationElement be = bindingElementCollection.ConfiguredBindings[0];

                Binding binding = GetBinding(be);
                if (be != null)
                {
                    be.ApplyConfiguration(binding);
                }

                return binding;
            }

            return null;
        }

        /**//// <summary>
        /// 一些创建匹配绑定的方法
        /// </summary>
        /// <param name="configurationElement"></param>
        /// <returns></returns>
        private Binding GetBinding(IBindingConfigurationElement configurationElement)
        {
            if (configurationElement is CustomBindingElement)
                return new CustomBinding();
            else if (configurationElement is BasicHttpBindingElement)
                return new BasicHttpBinding();
            else if (configurationElement is NetMsmqBindingElement)
                return new NetMsmqBinding();
            else if (configurationElement is NetNamedPipeBindingElement)
                return new NetNamedPipeBinding();
            else if (configurationElement is NetPeerTcpBindingElement)
                return new NetPeerTcpBinding();
            else if (configurationElement is NetTcpBindingElement)
                return new NetTcpBinding();
            else if (configurationElement is WSDualHttpBindingElement)
                return new WSDualHttpBinding();
            else if (configurationElement is WSHttpBindingElement)
                return new WSHttpBinding();
            else if (configurationElement is WSFederationHttpBindingElement)
                return new WSFederationHttpBinding();

            return null;
        }

        /**//// <summary>
        /// 添加configured behavior 到所选择的终结点
        /// </summary>
        /// <param name="behaviorConfiguration"></param>
        /// <param name="serviceEndpoint"></param>
        /// <param name="group"></param>
        private void AddBehaviors(string behaviorConfiguration, ServiceEndpoint serviceEndpoint, ServiceModelSectionGroup group)
        {
            //如果没有配置客户端行为则不执行
            if (String.IsNullOrEmpty(behaviorConfiguration))
            {
                return;
            }

            EndpointBehaviorElement behaviorElement = group.Behaviors.EndpointBehaviors[behaviorConfiguration];
            for (int i = 0; i < behaviorElement.Count; i++)
            {
                BehaviorExtensionElement behaviorExtension = behaviorElement[i];
                object extension = behaviorExtension.GetType().InvokeMember("CreateBehavior",
                    BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance,
                    null, behaviorExtension, null);
                if (extension != null)
                {
                    serviceEndpoint.Behaviors.Add((IEndpointBehavior)extension);
                }
            }
        }

        /**//// <summary>
        /// 从配置文件重获取终结点的identity 
        /// </summary>
        /// <param name="element"></param>
        /// <returns></returns>
        private EndpointIdentity GetIdentity(IdentityElement element)
        {
            EndpointIdentity identity = null;
            PropertyInformationCollection properties = element.ElementInformation.Properties;
            if (properties["userPrincipalName"].ValueOrigin != PropertyValueOrigin.Default)
            {
                return EndpointIdentity.CreateUpnIdentity(element.UserPrincipalName.Value);
            }
            if (properties["servicePrincipalName"].ValueOrigin != PropertyValueOrigin.Default)
            {
                return EndpointIdentity.CreateSpnIdentity(element.ServicePrincipalName.Value);
            }
            if (properties["dns"].ValueOrigin != PropertyValueOrigin.Default)
            {
                return EndpointIdentity.CreateDnsIdentity(element.Dns.Value);
            }
            if (properties["rsa"].ValueOrigin != PropertyValueOrigin.Default)
            {
                return EndpointIdentity.CreateRsaIdentity(element.Rsa.Value);
            }
            if (properties["certificate"].ValueOrigin != PropertyValueOrigin.Default)
            {
                X509Certificate2Collection supportingCertificates = new X509Certificate2Collection();
                supportingCertificates.Import(Convert.FromBase64String(element.Certificate.EncodedValue));
                if (supportingCertificates.Count == 0)
                {
                    throw new InvalidOperationException("UnableToLoadCertificateIdentity");
                }
                X509Certificate2 primaryCertificate = supportingCertificates[0];
                supportingCertificates.RemoveAt(0);
                return EndpointIdentity.CreateX509CertificateIdentity(primaryCertificate, supportingCertificates);
            }

            return identity;
        }


        protected override void ApplyConfiguration(string configurationName)
        {
            base.ApplyConfiguration(configurationName);
        }

    }