WCF自寄宿

WCF很早就出现了，然而我感受到能够让新手重点去学习WCF而不是WebService是最近两年。我相信大部分人初步了解WCF的时候会很痛苦，尤其是生成代理类，以及配置的问题。我本人其实比较讨厌配置编程，但喜欢轻量配置，因此也一直研究如何自己定义配置节点，去让WCF服务识别，然后重量级ABC操作由编码来完成。下面，我将会提供一个我本人用于学习其他知识需要使用WCF时的开发模式，另外说明，为了更好的说明，我将提供的都是精简版本，并不适合用于测试生产的例子。

1.定义适合自己的配置

public class WCFServiceElement : ConfigurationElement
{
        [ConfigurationProperty(name: "ServiceName", IsRequired = false)]
        public string ServiceName
        {
            get
            {
                return (base["ServiceName"] as string);
            }
            set
            {
                base["ServiceName"] = value;
            }
        }

        [ConfigurationProperty(name: "ServiceAssembly", IsRequired = false)]
        public string ServiceAssembly
        {
            get
            {
                return (base["ServiceAssembly"] as string);
            }
            set
            {
                base["ServiceAssembly"] = value;
            }
        }

        [ConfigurationProperty(name: "InterfaceServiceName", IsRequired = false)]
        public string InterfaceServiceName
        {
            get
            {
                return (base["InterfaceServiceName"] as string);
            }
            set
            {
                base["InterfaceServiceName"] = value;
            }
        }

        [ConfigurationProperty(name: "InterfaceServiceAssembly", IsRequired = false)]
        public string InterfaceServiceAssembly
        {
            get
            {
                return (base["InterfaceServiceAssembly"] as string);
            }
            set
            {
                base["InterfaceServiceAssembly"] = value;
            }
        }

        [ConfigurationProperty(name: "IPAddress", IsRequired = false)]
        public string IPAddress
        {
            get
            {
                return (base["IPAddress"] as string);
            }
            set
            {
                base["IPAddress"] = value;
            }
        }

        [ConfigurationProperty(name: "Binding", IsRequired = false)]
        public string Binding
        {
            get
            {
                return (base["Binding"] as string);
            }
            set
            {
                base["Binding"] = value;
            }
        }
}

public class WCFServicesElementCollection : ConfigurationElementCollection
    {
        protected override ConfigurationElement CreateNewElement()
        {
            ConfigurationElement _element = new WCFServiceElement();
            return _element;
        }

        protected override object GetElementKey(ConfigurationElement element)
        {
            WCFServiceElement _element = (WCFServiceElement)element;
            return _element.ServiceName;
        }

        protected override string ElementName
        {
            get
            {
                return "WCFService";
            }
        }

        public override ConfigurationElementCollectionType CollectionType
        {
            get
            {
                return ConfigurationElementCollectionType.BasicMap;
            }
        }
}

public class WCFServiceSection : ConfigurationSection
{
        [ConfigurationProperty(name: "", IsDefaultCollection = true, IsRequired = false)]
        public WCFServicesElementCollection WCFServices
        {
            get
            {
                return (base[""] as WCFServicesElementCollection);
            }
            set
            {
                base[""] = value;
            }
        }
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="WCFServices" type="Basic.Configuration.WCFServiceSection,Basic.Data"/>
  </configSections>
  <WCFServices>
    <WCFService ServiceName="AppManagementImplementation"
ServiceAssembly="Service.BackgroundManagement.Implementation"
                          InterfaceServiceName="IAppManagement"
InterfaceServiceAssembly="Service.BackgroundManagement.Interface"
                          IPAddress="http://192.168.1.4:8085/AppManagementService" 
                          Binding="WSHttpBinding">
    </WCFService>
  </WCFServices>
</configuration>

这里注意的是configSections一定要放在第一行，这个倒是听让人无语的。当然配置可以用自己希望方式配置，我这里提供一个简单的思路。

2.定义适合自己的WCFServerConfigurationManagement

public abstract class WCFServerConfigurationManagement
{
        private static HybridDictionary _Collection = new HybridDictionary();

        public static void Register()
        {
            WCFServiceSection section = ConfigurationManager.GetSection("WCFServices") as WCFServiceSection;
            if (null == section)
            {
                throw new NullReferenceException("未能识别WCFServices,请确认configSections配置节点");
            }

            _Collection.Clear();

            foreach (WCFServiceElement element in section.WCFServices)
            {
                Assembly assemblyInterfaceService = Assembly.Load(element.InterfaceServiceAssembly);
                Assembly assemblyService = Assembly.Load(element.ServiceAssembly);

                Type typeInterface = assemblyInterfaceService.ExportedTypes.FirstOrDefault(type => type.Name.Equals(element.InterfaceServiceName));
                Type typeImplement = assemblyService.ExportedTypes.FirstOrDefault(type => type.Name.Equals(element.ServiceName));

                if (null == typeInterface && null == typeImplement)
                {
                    throw new NullReferenceException("无法加载服务");
                }

                ServiceHost _NewHost = new ServiceHost(typeImplement);
                Binding binding = CreateBinding(element.Binding);
                _NewHost.AddServiceEndpoint(typeInterface, binding, element.IPAddress);
                
                _NewHost.Opened += (sender, e) =>
                {
#if DEBUG
                    Console.WriteLine($"服务:{element.ServiceName} 已经开启.");
#endif
                };
                _NewHost.Open();
            }
        }

        public static Binding CreateBinding(string bindingType)
        {
            Binding _Binding = default(Binding);
            switch (bindingType)
            {
                case "BasicHttpBinding":
                    _Binding = new BasicHttpBinding();
                    break;
                case "WSHttpBinding":
                    _Binding = new WSHttpBinding();
                    break;
                case "WS2007HttpBinding":
                    _Binding = new WS2007HttpBinding();
                    break;
                default:
                    throw new ArgumentNullException("根据接口名称无法匹配绑定类型");
            }

            return _Binding;
        }
}

这里主要用来根据配置动态配置WCF ServiceHost 和 Binding 的.然后再您的Custom Host 里面调用如下：

class Program
{
        static void Main(string[] args)
        {
            WCFServerConfigurationManagement.Register();

            Console.ReadLine();
        }
}

3.定义适合自己的WCFClientConfigurationManagement

public abstract  class WCFClientConfigurationManagement
{
        private static HybridDictionary _Collection = new HybridDictionary();

        public static void Register()
        {
            WCFServiceSection section = ConfigurationManager.GetSection("WCFServices") as WCFServiceSection;
            if (null == section)
            {
                throw new NullReferenceException("未能识别WCFServices,请确认configSections配置节点");
            }

            _Collection.Clear();

            foreach (WCFServiceElement element in section.WCFServices)
            {
                _Collection.Add(element.InterfaceServiceName , element);
            }
        }

        public static Binding CreateBinding(string serviceName)
        {
            Binding _Binding = default(Binding);
            WCFServiceElement element = _Collection[serviceName] as WCFServiceElement;
            if (null == element)
            {
                Register();
                element = _Collection[serviceName] as WCFServiceElement;
                if (null == element)
                {
                    throw new NullReferenceException("可能配置出现严重错误,根据接口名称无法获取配置文件信息.");
                }
            }

            switch (element.Binding)
            {
                case "BasicHttpBinding":
                    _Binding = new BasicHttpBinding();
                    break;
                case "WSHttpBinding":
                    _Binding = new WSHttpBinding();
                    break;
                case "WS2007HttpBinding":
                    _Binding = new WS2007HttpBinding();
                    break;
                default:
                    throw new ArgumentNullException("根据接口名称无法匹配绑定类型");
            }

            return _Binding;
        }

        public static EndpointAddress CreateAddress(string serviceName)
        {
            WCFServiceElement element = _Collection[serviceName] as WCFServiceElement;
            if (null == element)
            {
                Register();
                element = _Collection[serviceName] as WCFServiceElement;
                if (null == element)
                {
                    throw new NullReferenceException("可能配置出现严重错误,根据接口名称无法获取配置文件信息.");
                }
            }

            EndpointAddress _Address = new EndpointAddress(element.IPAddress);
            return _Address;
        }
}

这里主要用来根据配置动态配置WCF Client 和 Binding 的。然后再您的客户端以及配置文件注册如下（我这里提供的是ASP.NET MVC 5 的环境）：

public class MvcApplication : HttpApplication
{
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            WCFClientConfigurationManagement.Register();
        }
 }

<configuration>
  <configSections>
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
    <section name="WCFServices" type="Basic.Configuration.WCFServiceSection,Basic.Data"/>
  </configSections>
<WCFServices>
    <WCFService InterfaceServiceName="IAppManagement"
                          IPAddress="http://192.168.1.4:8085/AppManagementService"
                          Binding="WSHttpBinding">
    </WCFService>
</WCFServices>
</configuration>

4.定义适合自己的WCF ClientBase

public class WCFClient
{
        public static TResult ClientInvoke<TChannel , TResult>(Func<TChannel , TResult> functionInvoke)
        {
            string _ServiceName = typeof(TChannel).Name;
            Binding binding = WCFClientConfigurationManagement.CreateBinding(_ServiceName);
            EndpointAddress address = WCFClientConfigurationManagement.CreateAddress(_ServiceName);
            TChannel _channel = ChannelFactory<TChannel>.CreateChannel(binding, address);
            TResult _Result = functionInvoke.Invoke(_channel);
            return _Result;
        }
}

以上交代完毕，当然提醒初步了解WCF的人IPAddress 配置也可以写*.svc地址，可以在自寄宿在Windows Service 里，也可以是IIS宿主环境。写到这里，希望这篇随笔能帮助到需要帮助的人，这也就是它的价值所在了。