WCF读取配置动态生成客户端对象

最新推荐文章于 2023-07-25 16:26:41 发布
最新推荐文章于 2023-07-25 16:26:41 发布
阅读量5.2k 收藏 4
点赞数
分类专栏： WCF C# 文章标签： wcf binding string null exception action
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ALLsharps/article/details/7356301
版权
C# 同时被 2 个专栏收录
19 篇文章 0 订阅
订阅专栏
WCF
4 篇文章 0 订阅
订阅专栏

写一个类,用于动态生成WCFClient对象,无须每个WCF服务生成一个对应的配置,

 public class WcfServiceFactory
    {
        /// <summary>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="action"></param>
        /// <param name="host">(127.0.0.1)</param>
        /// <param name="port">1-65535</param>
        public static void Execute<T>(string host = null, short port = 0,params Action<T>[] action) where T : class,IDisposable, ICommunicationObject, new()
        {
            Execute("COMM",host,port,action);
        }
        /// <summary>
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="bindingName">设置中Binding的名子.</param>
        /// <param name="action">The action.</param>
        /// <param name="host">(127.0.0.1)</param>
        /// <param name="port">1-65535</param>
        /// <remarks></remarks>
        public static void Execute<T>(string bindingName,string host = null, short port = 0,params Action<T>[] action) where T : class,IDisposable, ICommunicationObject, new()
        {
            Execute(null, bindingName,host,port, action);
        }

        /// <summary>
        /// 执行WCF
        /// </summary>
        /// <typeparam name="T">服务Client类型</typeparam>
        /// <param name="strServiceUrl">服务URL(如果为空,则从web.Config中读取名子为COMM的URL)</param>
        /// <param name="bindingName">设置中Binding的名子</param>
        /// <param name="host">(127.0.0.1)</param>
        /// <param name="port">1-65535</param>
        /// <param name="exception">寻常</param>
        /// <param name="action">要执行服务的方法列表</param>
        /// <remarks></remarks>
        public static void Execute<T>(string strServiceUrl, string bindingName, string host = null, short port = 0, Action<Exception> exception = null, params Action<T>[] action) where T : IDisposable, ICommunicationObject, new()
        {
            using (var t = GetInstance<T>(strServiceUrl,host,port, bindingName))
            {
                action.ToList().ForEach(f =>
                                            {
                                                if (exception != null)
                                                {
                                                    try
                                                    {
                                                        f(t);
                                                    }
                                                    catch(Exception e)
                                                    {
                                                        exception(e);
                                                    }
                                                }
                                                else
                                                {
                                                    f(t);
                                                }
                                            });
            }
        }

        /// <summary>
        /// 执行WCF,并返回值
        /// </summary>
        /// <typeparam name="TClient">服务Client类型</typeparam>
        /// <typeparam name="TResult">返回值</typeparam>
        /// <param name="strServiceUrl">服务URL(如果为空,则从web.Config中读取名子为COMM的URL)</param>
        /// <param name="bindingName">设置中Binding的名子</param>
        /// <param name="host">(127.0.0.1)</param>
        /// <param name="port">1-65535</param>
        /// <param name="exception">寻常</param>
        /// <param name="action">要执行服务的方法列表</param>
        /// <returns></returns>
        public static TResult ExecuteReturn<TClient, TResult>(string strServiceUrl, string bindingName, string host = null, short port = 0, Action<Exception> exception = null, params Func<TClient, TResult>[] action)
            where TClient : IDisposable, ICommunicationObject, new()
        {
            TResult re = default(TResult);
            using (var t = GetInstance<TClient>(strServiceUrl, host, port, bindingName))
            {
                action.ToList().ForEach(f =>
                                            {
                                                if (exception != null)
                                                {
                                                    try
                                                    {
                                                        re = f(t);
                                                    }
                                                    catch (Exception e)
                                                    {
                                                        exception(e);
                                                    }
                                                }
                                                else
                                                {
                                                    re = f(t);
                                                }
                                            });
            }
            return re;
        }

        /// <summary>
        /// 执行WCF
        /// </summary>
        /// <typeparam name="T">服务Client类型</typeparam>
        /// <param name="strServiceUrl">服务URL(如果为空,则从web.Config中读取名子为COMM的URL)</param>
        /// <param name="bindingName">设置中Binding的名子</param>
        /// <param name="host">(127.0.0.1)</param>
        /// <param name="port">1-65535</param>
        /// <param name="action">要执行服务的方法列表</param>
        /// <remarks></remarks>
        public static void Execute<T>(string strServiceUrl, string bindingName, string host = null, short port = 0, params Action<T>[] action) where T : IDisposable, ICommunicationObject, new()
        {
            Execute(null, bindingName, host, port,null, action);
        }
        public static T GetInstance<T>(string strServiceUrl) where T : IDisposable, ICommunicationObject, new()
        {
            return GetInstance<T>(strServiceUrl,null);
        }
        /// <summary>
        /// 返回设置中名子为bindingName的Uri
        /// </summary>
        /// <param name="bindingName"></param>
        /// <returns></returns>
        public static Uri GetEndpointAddress(string bindingName)
        {
            var client = WCFConfigHelper.GetChannelEndpointElement(bindingName,false);
            if(client!=null)
            {
                return client.Address;
            }
            return null;
        }
        /// <summary>
        /// 创建一个WCF服务实例
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strServiceUrl">WCF Service Url</param>
        /// <param name="host">(127.0.0.1)</param>
        /// <param name="port">1-65535</param>
        /// <param name="bindingName">设置中Binding的名子</param>
        /// <returns>WCF服务实例</returns>
        /// <remarks></remarks>
        public static T GetInstance<T>(string strServiceUrl = null,string host = null,short port = 0,string bindingName = "COMM") where T : IDisposable, ICommunicationObject, new()
        {
            T _instance = default(T);
            string serviceUri = strServiceUrl;

            object[] paras = new object[2];
            BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None);

            //返回设置
            var bindConfig = WCFConfigHelper.GetBasicHttpBindingElement(bindingName, true);
            bindConfig.ApplyConfiguration(binding);//应用设置

            EndpointAddress address;
            if (serviceUri == null)//从设置中返回URL
            {
                var client = WCFConfigHelper.GetChannelEndpointElement(bindingName, true);
                var endpoint = client.Address;
                string url = string.Format(endpoint.ToString(), GetServerName<T>());
                Uri temp = new Uri(url);
                Uri newUri = temp;
                if (host != null)//如果输入参数中有HOST,则替换源设置中的HOST及端口
                {
                    if (port == 0) port = 80;
                    newUri = new Uri(string.Format("http://{0}:{1}{2}", host, port, temp.PathAndQuery));
                }
                //WCF访问地址
                address = new EndpointAddress(newUri);
            }
            else
            {
                address = new EndpointAddress(strServiceUrl);
            }
            //WCF设置及WCF地址
            paras[0] = binding;
            paras[1] = address;

            ConstructorInfo constructor;

            try
            {
                Type[] types = new Type[2];
                types[0] = typeof(Binding);
                types[1] = typeof(EndpointAddress);                
                constructor = typeof(T).GetConstructor(types);//声明调用哪个构造
            }
            catch (Exception)
            {
                return _instance;
            }

            if (constructor != null)
                _instance = (T)constructor.Invoke(paras);//调用构造生成WCF访问类

            return _instance;
        }

        /// <summary>
        /// 根据CLIENT返回接口类型名子,
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        private static string GetServerName<T>()
        {
            Type t = typeof (T);
            var interFace =
                t.GetInterfaces().FirstOrDefault(w => w.IsDefined(typeof (ServiceContractAttribute), false));

            if (interFace != null)
            {
                return interFace.Name;
            }
            return "";
        }
    }
读取设置类


/// <summary>
    /// 读取WCF设置
    /// </summary>
    public static class WCFConfigHelper
    {
        #region Section
        
        /// <summary>
        /// 返回Bindings设置
        /// </summary>
        /// <returns></returns>
        public static BindingsSection GetBindingsSection()
        {
            return ConfigurationManager.GetSection("system.serviceModel/bindings") as BindingsSection;
        }
        /// <summary>
        /// 返回ServicesSection设置
        /// </summary>
        /// <returns></returns>
        public static ServicesSection GetServicesSection()
        {
            return ConfigurationManager.GetSection("system.serviceModel/services") as ServicesSection;
        }
        /// <summary>
        /// 返回BehaviorsSection设置
        /// </summary>
        /// <returns></returns>
        public static BehaviorsSection GetBehaviorsSection()
        {
            return ConfigurationManager.GetSection("system.serviceModel/behaviors") as BehaviorsSection;
        }
        /// <summary>
        /// 返回ClientSection设置
        /// </summary>
        /// <returns></returns>
        public static ClientSection GetClientSection()
        {
            return ConfigurationManager.GetSection("system.serviceModel/client") as ClientSection;
        }
        #endregion

        #region Binding
        /// <summary>
        /// 返回BasicHttpBinding设置
        /// </summary>
        /// <returns></returns>
        public static BasicHttpBindingElement GetBasicHttpBindingElement(string name,bool returnDefault)
        {
            var list = GetBindingsSection().BasicHttpBinding.Bindings.Cast<BasicHttpBindingElement>();
            var re = list.FirstOrDefault(w => w.Name == name);
            if (re == null && returnDefault) re = list.FirstOrDefault();
            return re;
        }
        /// <summary>
        /// 返回NetTcpBindingElement设置
        /// </summary>
        /// <returns></returns>
        public static NetTcpBindingElement GetNetTcpBindingElement(string name,bool returnDefault)
        {
            var list = GetBindingsSection().NetTcpBinding.Bindings.Cast<NetTcpBindingElement>();
            var re = list.FirstOrDefault(w => w.Name == name);
            if (re == null && returnDefault) re = list.FirstOrDefault();
            return re;
        }
        /// <summary>
        /// 返回WSHttpBindingElement设置
        /// </summary>
        /// <returns></returns>
        public static WSHttpBindingElement GetWSHttpBindingElement(string name, bool returnDefault)
        {
            var list = GetBindingsSection().WSHttpBinding.Bindings.Cast<WSHttpBindingElement>();
            var re = list.FirstOrDefault(w => w.Name == name);
            if (re == null && returnDefault) re = list.FirstOrDefault();
            return re;
        }
        #endregion

        #region Behaviors

        /// <summary>
        /// 返回ServiceBehaviorElement设置
        /// </summary>
        /// <returns></returns>
        public static ServiceBehaviorElement GetServiceBehaviorElement(string name, bool returnDefault)
        {
            var list = GetBehaviorsSection().ServiceBehaviors.Cast<ServiceBehaviorElement>();
            var re = list.FirstOrDefault(w => w.Name == name);
            if (re == null && returnDefault) re = list.FirstOrDefault();
            return re;
        }
        #endregion

        /// <summary>
        /// 返回设置是的ChannelEndpointElement
        /// </summary>
        /// <param name="name"></param>
        /// <param name="returnDefault"></param>
        /// <returns></returns>
        public static ChannelEndpointElement GetChannelEndpointElement(string name, bool returnDefault)
        {
            var list = GetClientSection().Endpoints.Cast<ChannelEndpointElement>();
                
            var re = list.FirstOrDefault(w => w.Name == name);
            if (re == null && returnDefault) re = list.FirstOrDefault();
            return re;
        }
    }

使用方法 

#region 通用Execute

        /// <summary>
        /// 使用设置接口设置执行WCF(默认接口设置为COMM)
        /// </summary>
        /// <typeparam name="TClient">WCF客户端代理</typeparam>
        /// <param name="port">设置WCF服务的端口号</param>
        /// <param name="action">要执行WCF的方法</param>
        /// <param name="host">设置WCF服务的服务器名称或IP</param>
        public static void Execute<TClient>(string host = null, short port = 0, Action<TClient> action = null)
                where TClient : class, IDisposable, ICommunicationObject, new()
        {
            Execute(null, "COMM", host, port, action);
        }

        /// <summary>
        /// 执行WCF
        /// </summary>
        /// <typeparam name="TClient">服务Client类型</typeparam>
        /// <param name="strServiceUrl">服务URL(如果为空,则从web.Config中读取名子为COMM的URL)</param>
        /// <param name="binding">设置中Binding的名子.</param>
        /// <param name="port">设置WCF服务的端口号</param>
        /// <param name="exceptionAction">调用WCF错误时执行的方法</param>
        /// <param name="action">要执行服务的方法列表</param>
        /// <param name="host">设置WCF服务的服务器名称或IP</param>
        /// <remarks></remarks>
        public static void Execute<TClient>(string strServiceUrl = null, string binding = null, string host = null,
                                      short port = 0, Action<Exception> exceptionAction = null, Action<TClient> action = null)
                where TClient : IDisposable, ICommunicationObject, new()
        {
            WcfServiceFactory.Execute(strServiceUrl, binding, host, port, exceptionAction, action);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strServiceUrl"></param>
        /// <param name="binding"></param>
        /// <param name="host"></param>
        /// <param name="port"></param>
        /// <param name="action"></param>
        /// <typeparam name="TClient"></typeparam>
        public static void Execute<TClient>(string strServiceUrl = null, string binding = null, string host = null,
                                      short port = 0, Action<TClient> action = null)
                where TClient : IDisposable, ICommunicationObject, new()
        {
            Execute(strServiceUrl, binding, host, port, null, action);
        }
        #endregion

        #region 通用ExecuteReturn
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TClient">服务Client类型</typeparam>
        /// <typeparam name="TResult">执行WCF服务的返回数据类型</typeparam>
        /// <param name="strServiceUrl">设置WCF服务的地完整地址</param>
        /// <param name="binding">设置中Binding的名子.</param>
        /// <param name="host">设置WCF服务的服务器名称或IP</param>
        /// <param name="port">设置WCF服务的端口</param>
        /// <param name="exceptionAction"></param>
        /// <param name="action">要执行WCF的方法</param>
        /// <returns></returns>
        public static TResult ExecuteReturn<TClient, TResult>(string strServiceUrl = null, string binding = null,
                                                              string host = null, short port = 0,
                                                              Action<Exception> exceptionAction = null,
                                                              Func<TClient, TResult> action = null)
                where TClient : IDisposable, ICommunicationObject, new()
        {
            return WcfServiceFactory.ExecuteReturn(strServiceUrl, binding, host, port, exceptionAction, action);
        }
        #endregion
添加配置,aaa无用,但必须设置,COMM在调用时使用,{0}为服务名,自动匹配 
<endpoint address="http://localhost:1234/Services/{0}.svc" binding="basicHttpBinding"
        contract="aaa" name="COMM" />
<basicHttpBinding>
        <binding name="AAA" closeTimeout="00:01:00" openTimeout="00:01:00"
          receiveTimeout="00:10:00" sendTimeout="00:01:00" allowCookies="false"
          bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
          maxBufferSize="96553600" maxBufferPoolSize="52428800" maxReceivedMessageSize="96553600"
          messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered"
          useDefaultWebProxy="true">
          <readerQuotas maxDepth="3200" maxStringContentLength="81920000"
            maxArrayLength="91638400" maxBytesPerRead="409600" maxNameTableCharCount="91638400" />
          <security mode="None">
            <transport clientCredentialType="None" proxyCredentialType="None"
              realm="" />
            <message clientCredentialType="UserName" algorithmSuite="Default" />
          </security>
        </binding>
      </basicHttpBinding>



ALLsharps
关注
专栏目录
C#WCF和HTTP文件传输练习.zip
07-06
客户端需要引用WCF服务的元数据（通常为*.svc或*.wsdl文件），以便生成与服务交互所需的代理类。 调用服务时，客户端通过代理类的`DownloadFile`方法发起请求，获取到流对象后，可以将其写入本地文件系统，从而完成...
WCF 接口动态调用（动态创建实例接口）
无趣哦
03-26 1343
很多时候，服务地址都不止一个的，这个时候就要动态去配置地址。配置Web.config，很麻烦！！！ 在这里我们就先来给大家介绍一种比较简单的应用技巧，WCF动态创建代码的相关实现方法。 一、服务端创建WCF： public interface ISysInfoService { [OperationContract] st
WCF测试客户端(WcfTestClient)
Just do it!
09-11 9427
背景   在建立WCF服务程序的时候，通常需要进行测试，当然测试的方法有很多种，这里介绍微软用来测试服务的GUI工具WcfTestClient.exe，很好用的工具。 打开   在VS之外打开测试客户端有两种方法： 找到WCF测试客户端的所在路径（VS安装路径\Common7\IDE），我安装的是VS2012，在**C:\Program Files (x86)\Microsoft Vi
WCF基本实现（Server和Client）
C# Socket通信
07-20 1969
Windows Communication Foundation(WCF)是由微软开发的一系列支持数据通信的应用程序框架，可以很多传输协议与WCF服务进行通信。常见的5个协议有： （1）HTTP：允许与WCF服务通信，可使用HTTP通信技术创建WCF Web服务。 （2）TCP：可以通过TCP协议与WCF服务通信，效率较高。 （3）UDP：采用UDP协议与WCF服务通信。 （4）命名管道：该
WCF服务/客户端
最新发布
gqk01的博客
07-25 411
打开service1 类文件, 集成于Iservice1 的接口并且有具体实现, 在我们测试中, 则是利用客户端进行访问进行演示, 而下面,要讲的技术一个关于终结点的概念。本地或者是异地的消息接收程序再从该队列中取出发给它的消息进行处理。它是一种异步传输模式，可以在不同的应用之间实现相互通信，相互通信的应用可以分布在同一台机器上，也可以分布于相连的网络空间中的任一位置。在我们的实际开发过程中, 需要用于数据交互的实体类, 则必须声明类及成员的数据协定, 声明的意义则表示该实体可以序列化。
.NET Core开发日志——WCF Client
aixing8475的博客
07-24 401
WCF作为.NET Framework3.0就被引入的用于构建面向服务的框架在众多项目中发挥着重大作用。时至今日，虽然已有更新的技术可以替代它，但对于那些既存项目或产品，使用新框架重构的代价未必能找到人愿意买单。 而在.NET Core平台环境中，WCF也并没有被完全列入迁移目标。WCF的服务端被搁置一旁，只有客户端已被移植入.NET Core之中。 这意味着，如果有需求在.NET Co...
通用数据库Wcf和WebApi服务
05-16
标题中的“通用数据库Wcf和WebApi服务”指的是一个软件框架，它允许开发人员使用Entity Framework（EF）在WCF（Windows Communication Foundation）和Web API这两种不同的服务技术中快速构建数据库操作。WCF是.NET ...
WCF实现文件上传与下载
07-20
8. **客户端调用**：客户端通过生成代理类（使用`svcutil.exe`工具或`Add Service Reference`功能）来调用服务。调用服务的方法时，传递文件流以实现文件上传或接收返回的流来下载文件。 通过以上步骤，WCF可以在...
asp.net+wcf+entity framework
10-25
ASP.NET允许开发者使用C#或VB.NET等.NET兼容语言编写服务器端代码，以生成动态网页内容。 **WCF** WCF是微软提供的一个全面的服务导向架构（SOA）工具，用于构建高度可互操作的分布式系统。它允许开发者创建、部署...
使用WCF REST API和JavaScript上传文件
04-05
在IT行业中，Web服务是应用程序之间进行通信的重要方式，而WCF（Windows Communication Foundation）是.NET框架中的一个组件，用于构建、配置和部署服务。本文将深入探讨如何使用WCF REST API与JavaScript相结合来...
WcfTestClient.7z 可用版本 不用装VS
02-09
在Visual Studio 2010里提取出来的，可以连接svc服务，只是不能编辑，对于某些服务器与外界隔离，又想测试服务是否正常的情况很有用，以前都是自己写工具，现在可以用这个了。 这是个提取版本，没有配置编辑功能，因为要有这个功能得装SDK,500M。
【应用篇】WCF学习笔记（一）：Host、Client、MetadataExchage
weixin_34320724的博客
10-24 153
虽然已经在多个项目中成功应用过WCF，但是感觉自己对WCF的知识只知道一些皮毛而已。上次学习WCF也是为了项目需要，囫囵吞枣。这不是我学习方法的态度。所以时至今日，又重新拾卷，再仔细的将WCF一些细节知识，边边角角自己回顾一番。   Host 三种Host的方式：IIS Host、WAS Host、Self-Host。 IIS Host IIS这种非常简单，但只支持HTTP协议。不过，你...
动态生成WCF服务端的简单小例子
cjwix2012的专栏
08-13 565
为了简单明了我只建了一个控制台程序将
学习 WCF (4)--学会使用配置文件
u014712365的博客
08-08 64
无论是Web应用程序还是Win应用程序，我们都会经常用到配置文件。WCF作为分布式开发的基础框架，在定义服务以及定义消费服务的客户端时，都使用了配置文件的方法。配置文件的重要性和实用性是大家所熟知的，它可以给我们WCF开发的灵活性上带来很大的提高。下面说说我学习使用配置文件的所得。 WCF的配置使用.NET Framework的System.Configuration配置系统。在Visua...
创建WCF客户端调用
mrtwenty的博客
08-12 443
创建一个新项目，WCF客户端，来调用我们的WCF服务端。我们使用控制台程序，运行环境用的是**.net core 3.1**.
WCF 动态调用（动态创建实例接口）
caikeyter
09-04 2万+
很多时候，服务地址都不止一个的，这个时候就要动态去配置地址。配置Web.config，很麻烦 下面就看看怎样实现动态调用WCF。 首先看看动态创建服务对象的代码： using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.ServiceModel; u
动态生成WCF客户端
cuihuinao1293的博客
07-19 103
原作者：博客园张玉彬CreateClientInstanceWays.rar ...
不引用服务而使用WCF，手动编写客户端代理类
热门推荐
老周——“易之道”
08-09 2万+
本文将演示如何通过自己手动编写代码来调用WCF服务。首先使用了ChannelFactory来创建通道，并调用与通道关联的服务协定。随后对代码进一步封装，选用从ClientBase类派生，可以更有效地简化代码，而且在处理有服务器回调的服务协定时也方便了许多。
WCF客户端配置详解：实现远程调用
"WCF例子程序客户端运行详细配置参考，主要涵盖了WCF服务的客户端配置、服务端逻辑以及整体架构的介绍，旨在帮助开发者解决在分布式环境中运行WCF应用程序的实际问题。" WCF（Windows Communication Foundation）是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值