.NET 跨平台RPC框架DotNettyRPC Web后台快速开发框架（.NET Core） EasyWcf------无需配置，无需引用，动态绑定，轻松使用 C# .NET 0配置使用Wcf(半成品) C# .NET Socket 简单实用框架 C# .NET 0命令行安装Windows服务程序
.NET 跨平台RPC框架DotNettyRPC
DotNettyRPC
1.简介
DotNettyRPC是一个基于DotNetty的跨平台RPC框架，支持.NET45以及.NET Standard2.0
2.产生背景
传统.NET开发中遇到远程调用服务时，多以WCF为主。而WCF虽然功能强大，但是其配置复杂，不易于上手。而且未来必定是.NET Core的天下,WCF暂不支持.NET Core（只有客户端，无法建立服务端）。市面上的其他.NET的 RPC框架诸如gRPC、surging甚至微服务框架Orleans等，这些框架功能强大，性能也很好，并且比较成熟，但是使用起来不够简单。基于上述比较（无任何吹捧贬低的意思），鄙人不才撸了一个轮子DotNettyRPC，它的定位是一个跨平台(.NET45和.NET Standard)、简单却实用的RPC框架
3.使用方法
3.1引入DotNettyRPC
打开Nuget包管理器，搜索DotNettyRPC即可找到并使用
或输入Nuget命令：Install-Package DotNettyRPC
3.2定义服务接口
public interface IHello
{
string SayHello(string msg);
}
public class Hello : IHello
{
public string SayHello(string msg)
{
return msg;
}
}3.3服务端
using Coldairarrow.DotNettyRPC;
using Common;
using System;
namespace Server
{
class Program
{
static void Main(string[] args)
{
RPCServer rPCServer = new RPCServer(9999);
rPCServer.RegisterService<IHello, Hello>();
rPCServer.Start();
Console.ReadLine();
}
}
}
3.4客户端
using Coldairarrow.DotNettyRPC;
using Common;
using System;
namespace Client
{
class Program
{
static void Main(string[] args)
{
IHello client = RPCClientFactory.GetClient<IHello>("127.0.0.1", 9999);
var msg = client.SayHello("Hello");
Console.WriteLine(msg);
Console.ReadLine();
}
}
}
3.5运行
先运行服务端,再运行客户端,即可在客户端输出Hello
4.结语
本机测试一次RPC请求平均0.4ms左右，性能不高，但是足以应对绝大多数业务场景，重在简单实用。可以优化的地方很多，还望大家多多支持。
GitHub地址：https://github.com/Coldairarrow/DotNettyRPC
QQ群：373144077
Web后台快速开发框架（.NET Core）
Web后台快速开发框架（.NET Core）
Coldairarrow
-
目录
目录
-
简介
本框架旨在为.NET开发人员提供一个Web后台快速开发框架，采用本框架，能够极大的提高项目开发效率。
整个框架包括三个版本：
.NET新版，采用.NET452,GitHub地址为：https://github.com/Coldairarrow/Coldairarrow.Fx.Net.Easyui.GitHub
.NET40版，采用.NET40,GitHub地址为：https://github.com/Coldairarrow/Coldairarrow.Fx.Net40.Easyui.GitHub
.NET Core版，采用.NET Core2.1, GitHub地址为：https://github.com/Coldairarrow/Coldairarrow.Fx.Core.Easyui.GitHub
以上三个版本中，.NET新版，主要支持最新的技术方案，作为主要生产版本；.NET40版是为了兼容Windows 2003服务器而降级的版本，功能正常。.NET Core 版本是未来的发展方向，能够跨平台，并且涉及Linux、Docker、Nginx、微服务等概念，已完成移植。
-
基础准备
-
开发环境要求
操作系统：Windows 10
开发工具：Visual Studio 2017
SDK：安装.NET Core2.1及以上
数据库：SQLServer2008 R2及以上（若在部署在Linux上访问SQLServer2008 R2请给数据库打上SP2+补丁，不然会出问题）
-
基础数据库构建
使用本框架需要构建基础数据库，具体步骤如下：
创建基础数据库的Sql脚本文件在：/docs/初始化文件/db.sql，在数据库中运行db.sql脚本即可创建数据库:Coldairarrow.Fx.Net.Easyui.Git
若Sql运行出错，请直接使用同目录下的Coldairarrow.Fx.Net.Easyui.GitHub.bak还原数据库
打开src目录下Coldairarrow.Fx.Net.Easyui.Git.sln的解决方案，如下图
如下图所示依次展开05.Coldairarrow.Web=> appsettings.json，配置数据库连接字符串，name不用修改，connectionString改为上述创建的数据库（若不清楚数据库连接字符串请自行百度搜索教程）
自此基础数据库配置完成。
-
运行
请先还原Nuget包
然后将05.Coldairarrow.Web设为启动项目，成功运行即可进入以下页面
-
详细教程
-
代码架构
-
总体架构
框架组成结构一共分为5层，如上图所示，分别如下：
基础设施层：此层为最底层，可以为其余所有层服务。主要提供了项目开发所需的各种帮助类：数据库访问帮助类、文件操作帮助类、二维码生成帮助类、分拣压缩帮助类等等其余帮助类；拓展类：字符串拓展类、集合操作拓展类、表达式树拓展类等等其余拓展类；还集成了个人编写的Socket通讯框架，WCF拓展使用框架，Windows服务容器。这些丰富的类库都是为开发人员提供了开发中常用的功能，为快速开发提供强有力的保障。
数据仓储层：这层主要为对数据库操作CRUD的简单封装，以EntityFramework为核心，采用简单工厂、抽象工厂、工厂方法、三个工厂设计模式，使开发人员进行CRUD只需要极为简单的代码即可完成。本层还提供了数据库事务的支持，更是提供了分布式事务支持，为数据库操作提供必备的保障。使用本层提供的接口，无需关心具体的数据库类型，比如是采用SQLServer数据库或者MySQL数据库，开发人员只需要关心具体的业务逻辑实现，哪怕更换数据库，也无需更改业务逻辑代码，只需要更改简单的数据库配置即可。总之，本层为开发人员对数据库的操作提供了简单高效的操作接口，可以极大的提高开发效率。
实体层：这层主要为ORM框架数据库表对应的实体类，为业务逻辑层和应用层服务。
业务逻辑层：本层是开发人员主要编写层，通过调用数据仓储层操作数据库，并为应用层提供所需的接口，处理具体操作的业务逻辑，可以说是最为复杂的一层。
应用层：本层在本框架中表现形式为ASP.NET MVC网站，其实也可以泛指其余的表现形式：控制台程序、Windows服务程序、WinForm程序、WPF程序等等。本层为具体的应用，负责系统功能的实现。
-
基础设施层
此层为最底层，可以为其余所有层服务。主要提供了项目开发所需的各种类库，主要为以下几种类库：
-
拓展帮助类
利用C#的语法糖（是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用），可以在类上拓展自定义方法，这样开发人员在使用的时候就可以十分的方便，既能减少重复的代码又能加快开发效率。具体包含但不限于以下类：
Object拓展：Object是所有类的基类。现在前后端数据交互中，采用JSON是选择，因此对象JSON序列化与反序列化的使用就十分的频繁，通过给Object拓展ToJson方法，就可以将数据对象直接转为对应的JSON字符串，能够极大的简化JSON序列化所需要的代码。
Byte拓展：Byte，即字节，一个字节是8个比特位，十进制数值范围在0-255。由于Byte与二进制是直接对应的，而计算机中一切数据都是二进制，所以关于Byte与其他数据类型之间的转换就显得尤为重要，编写Byte相关的拓展方法能够方便Byte的使用。例如，拓展将Byte数组转为16进制字符串的方法，能够将字节数组直接转为对应的16进制字符串，现在物联网的发展也十分的迅速，在物联网开发中，关键是建立与硬件之间的通信，但是由于硬件的配置一般都不高，因此与硬件之间的通信大多以字节为单位，这种情况下，使用该拓展方法就可以提高开发效率。
Expression拓展：Expression，即表达式树，在LINQ查询中经常使用。在日常使用中,Where筛选估计是用得最多的，但是大多数开发人员都是使用最原始的Where筛选，当筛选条件增多，筛选条件变复杂的时候，原始的Where虽然也可以胜任，但是就会导致代码重复，不够简洁雅观，此时可以为Expression<Func<T, bool>>类拓展And与Or方法，其中And是"与"操作，Or是"或"操作，这样就可以将多个筛选条件拼接在一起，十分的实用。
IQueryable<T>拓展：IQueryable<T>是提供针对特定数据源（其中数据类型未未知）评估查询的功能接口，其在EntityFramework中发挥着重要的作用。例如，在后台管理系统中，数据表格的使用最为普遍，前端向后台请求表格数据时，不外乎需要以下几个参数：当前请求页码、每页记录数、排序列与排序类型，这些参数在每个请求表格数据请求中都需要处理，这时，通过给IQueryable<T>拓展GetPagination<T>方法，只需要传入分页参数，就可以获取所需的数据表格数据，十分的方便高效。
-
工具帮助类
主要提供了常用的一些帮助类，包含但不限于：
Office办公文档导入导出帮助类：当今，随着人们环保意识的增强，以及各行业对办公模式需求的不断升级，现代化、信息化建设步伐的加快，无纸化办公已经由概念逐渐应用到多个行业领域中，办公中，各种办公文件，尤其是Excel文件与Word文件经常需要导入与导出，但是C#操作Excel与Word文件并不简单，经常困扰着开发者，由此，本框架提供了Office文档操作帮助类，封装简化了对办公文档的常用操作，能够降低开发难度，提高开发效率。
HTTP请求模拟帮助类：在传统网站开发中，一般都是前端浏览器向后台发起请求，但是，现在的系统与系统之间的合作越来越紧密，经常需要后端向后端发起请求，即需要后端模拟HTTP请求，但编写一个完整的HTTP请求并不是那么容易，因此本框架提供HTTP请求帮助类，开发人员只需要传入需要请求的URL地址与参数即可完成HTTP请求操作，使用起来简单高效，能够极大的提高开发效率。
-
缓存操作帮助类
在现代化系统开发中，随着业务量的增大，系统性能就难以满足要求，要达到性能要求，一方面可以采用更好的硬件，但是成本较高，而另一方面就是使用缓存，有效使用缓存能够提高吞吐量与并发量，所需成本较低，是绝大多数用户的首选。
.NET Framework框架提供了系统缓存，虽然使用简单方便，但是不支持分布式，因此大多选择诸如Redis和Memcached缓存，但是不同的缓存为开发者提供的接口不一样，当使用不同的缓存时开发人员又需要去学习别的缓存操作接口，十分的麻烦，为解决这个问题，本框架提供了缓存操作帮助类。缓存操作帮助类将缓存核心操作抽象定义成操作接口：添加缓存、删除缓存、设置缓存过期时间，然后再用Redis与系统缓存实现抽象接口，当使用缓存时可以使用同样的操作接口操作不同的缓存，能够降低开发人员学习成本，提高开发效率。
-
数据库操作帮助类
无论什么网站，只要需要对数据进行操作，那么大多离不开数据库。数据库目前使用最多的就是三大关系型数据库：SQLServer、MySQL与Oracle，访问数据库需要一系列的程序：首先需要创建数据库连接对象，紧接着打开数据库，其次传入数据库操作命令，然后执行命令，最后得到数据结果，若每次访问数据库都要写一遍这些流程，那么将会极大的阻碍开发效率，因此，本框架提供了数据库操作帮助类，将数据库操作所需要的流程封装，开发人员只需要关心具体的SQL语句的编写即可，并且支持三大关系型数据库，适合不同的开发人员使用。
-
-
数据仓储层
在后端开发中，数据库操作是最频繁的，每一个后端开发人员或多或少都会接触，甚至不少开发人员每天的工作就是与数据库打交道，所以可见数据库操作是多么的重要。在现在开发的过程中，绝大多数开发人员只是以编写SQL语句的方式操作数据库，这种方式是操作数据库最基本最原始的方式，简单高效，但是在编写SQL语句的过程中，极容易因马虎大意而编写错误，就会出现一个现象：开发人员面对着一堆SQL语句在DEBUG，而且每次都需要开发人员自己去手写SQL语句，其开发效率极低。哪怕开发人员足够出色，能够保证编写的SQL语句较低的出错率，但是，不同的数据库所需要的SQL语句还是有差异的，这就需要开发人员学习不同的数据库SQL语法，添加学习成本。而且在项目开发中难免会遇到更换数据库的情况，这时还需要花费大量的精力去进行修改SQL语句。
在本框架的数据仓储层中，上述问题即可迎刃而解。数据仓储层，不同于传统三层架构中的数据层，其核心继承关系图如下图所示（图6-1）：
图6-1 数据仓储类图
如上图所示，首先定义了数据操作接口IRepository,该接口包含了增、删、改、查、事物控制等数据库常用核心操作，能够满足对数据库的常用操作，DbRepository类实现了IRepository接口，主要以ORM框架Entity Framework为基础，封装实现了大部分IRepository所需的操作，SqlServerRepository、MySqlRepository和PostgreSqlRepository分别实现具体数据库对应的数据仓储，而且继承自同一个数据操作接口IRepository，因此在具体的使用上，可以实现以同一个操作方法访问不同的数据库，当遇到需要更换数据库的情况时，采用本框架开发的系统能够不改代码而正常运行，这一点能够极大的降低软件开发成本。并且以Entity Framework为核心，不需要编写SQL语句就能够完成绝大部分的数据库操作，再加上简洁的LINQ配合，彻底将开发人员从SQL语句中解放出来，让开发人员能够更加专注于业务逻辑的实现，能够极大的提高软件开发效率。
IRepository代码如下：
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;
namespace Coldairarrow.DataRepository
{
public interface IRepository
{
#region 数据库连接相关方法
DbContext GetDbContext();
#endregion
#region 事物提交
/// <summary>
/// 开始单库事物
/// 注意:若要使用跨库事务,请使用DistributedTransaction
/// </summary>
void BeginTransaction();
bool EndTransaction();
#endregion
#region 增加数据
void Insert<T>(T entity) where T : class, new();
void Insert<T>(List<T> entities) where T : class, new();
void BulkInsert<T>(List<T> entities) where T : class, new();
#endregion
#region 删除数据
void DeleteAll<T>() where T : class, new();
void Delete<T>(string key) where T : class, new();
void Delete<T>(List<string> keys) where T : class, new();
void Delete<T>(T entity) where T : class, new();
void Delete<T>(List<T> entities) where T : class, new();
void Delete<T>(Expression<Func<T, bool>> condition) where T : class, new();
#endregion
#region 更新数据
void Update<T>(T entity) where T : class, new();
void Update<T>(List<T> entities) where T : class, new();
void UpdateAny<T>(T entity, List<string> properties) where T : class, new();
void UpdateAny<T>(List<T> entities, List<string> properties) where T : class, new();
#endregion
#region 查询数据
T GetEntity<T>(object keyValue) where T : class, new();
List<T> GetList<T>() where T : class, new();
IQueryable<T> GetIQueryable<T>() where T : class, new();
DataTable GetDataTableWithSql(string sql);
DataTable GetDataTableWithSql(string sql, List<DbParameter> parameters);
List<T> GetListBySql<T>(string sqlStr) where T : class, new();
List<T> GetListBySql<T>(string sqlStr, List<DbParameter> parameters) where T : class, new();
#endregion
#region 执行Sql语句
void ExecuteSql(string sql);
void ExecuteSql(string sql, List<DbParameter> parameters);
#endregion
}
}
-
数据实体层
由于框架主要采用了Entity Framework作为ORM框架，这其中数据库实体映射必不可少，需要将数据库中每张表映射到类中，并且一张表一个类。这些实体类即能够作为数据库操作中的实体，还能够作为DTO(Data Transfer Object)，将这些实体类划分为独立的一层，能够方便对实体的管理，易于开发与维护。
-
业务逻辑层
在整个后端开发中，业务逻辑的处理是最复杂的，因为从技术角度来讲，很多技术都能够实现代码复用，即无需重复造轮子（重造轮子是重复创造一个已经存在的基本方法或者被其他人优化），而且只要会使用了就能够快速投入生产中，虽然技术可以从设计上实现代码重用，降低学习成本，但是不同的系统其业务逻辑通常是不可复制的，因此开发人员可以不关心具体数据仓储的实现技术，但是不得不关心具体业务逻辑的实现，既然业务逻辑无法避免又那么复杂，那么设计出合理的业务逻辑架构来加快开发效率就显得尤为重要。
本框架将业务逻辑独立一层，其核心继承关系如下图（图6-2）所示：
图6-2 业务逻层次图
如上图所示：首先定义了一个业务逻辑基类BaseBusiness<T>，该基类实现了所有调用数据仓储的方法，其余所有业务处理类都需要继承自基类BaseBusiness<T>，其中泛型T为数据库实体，一般默认操作但张表，但在实际运用中连表操作十分的普遍，因此在BaseBusiness中提供了Service属性，该属性为IRepository类型，因此可以操作泛型接口，传入不同的实体类型即可对应到所需表的操作，故而支持联表操作，方便开发人员操作数据库。基类还提供了通用业务逻辑返回数据，Success和Error分别对应成功请求返回和失败请求返回，统一数据格式，方便前后端开发对接。
-
应用展示层
这层也可以称之为应用层，其余的层表现形式都是类库，而这一层负责具体项目应用的实施，比如可以使用控制台程序、Windows服务程序、WinForm程序、WCF程序等等,在本项目中使用了ASP.NET MVC网站项目负责具体功能的实现。
AOP（Aspect Oriented Programming）使用：AOP，即面向切片编程，利用AOP能够将系统各个部分进行隔离，从而降低模块之间的耦合度，提高程序可用性，同时提高开发效率。本框架中主要使用了以下AOP：
管理员登录校验CheckLoginAttribute：在后台管理系统中，管理员只有登录后才能够进行相关操作，一般通过Session来记录管理员登录信息，最简单直接就是在每一个请求中都需要判断一遍管理员是否登录，这无疑将会导致很多的重复代码，此时，通过将登陆校验作为一个特性，只需要在需要登录的控制器或方法上添加该特性即可完成管理员登录校验，这样就能够减少大量的重复代码，加快开发效率。
签名校验CheckSignAttribute：当后端接口需要给外部系统调用时，若不对接口访问进行限制，那么就会面临恶意请求攻击的风险，轻则影响系统性能，重则导致系统瘫痪，数据被恶意串改，此时，保证接口的安全性就十分关键。保证接口的安全性，主要就是按照一定的签名算法，对请求者传入的参数进行签名校验，只有通过才能够正常访问，原始做法就是在每个请求中去进行签名校验，这同样会导致大量的重复代码，这时通过引入签名校验特性，只需要在需要签名校验的控制器或方法中加入特性即可，使用简单方便，开发效率也高。
应用层还在视图中使用了通用布局模板，并统一了代码规范，再集成了JQuery以及一些其它常用的JS类库，以Layui为主要前端UI框架，界面风格统一，开发效率高。
-
功能架构
-
全局配置
在01.Coldairarrow.Util中的GlobalSwitch类中，设置了各个参数，其中RunModel需要重点关注一下，若RunModel==RunModel.LocalTest，则系统会直接跳过登录，默认使用Admin超级管理员登录，其它参数请看注释。
-
快速开发
使用此功能请确保GlobalSwitch.RunModel= RunModel.LocalTest
此功能为本框架的核心功能，能够自动生产完整的可运行代码，具体使用如下：
首选需要有数据库源，因为代码生成是根据数据库表来生成的。
菜单：开发=>快速开发=>数据库连接管理
若列表中没有目标数据源，则添加数据库连接
数据连接名、连接字符串、数据库类型（目前不支持Oracle，有空余时间再研究）即可。添加完成后即可看到连接字符串信息。
有了数据库连接之后，即可进行代码生成。
菜单：开发=>快速开发=>代码生成
选择数据库，然后勾选需要生成代码的数据库表，点击生成代码会弹出生成选项（这里暂时只能勾选Dev_Project，其余表全是系统基础表，不要勾选，否则会被覆盖，导致异常，请勾选自己的业务表进行生成）：
生成选项中可以选择需要生成的类型，可以默认生成实体层、业务逻辑层、控制器和视图。
生成区域对应MVC中的Areas，请按需填入（必填）
这里示例填写ProjectManage，点击生成按钮，即可完成代码生成。生成后的代码在项目解决方案中，将代码文件包括进入项目
默认生成后的文件是隐藏的，需要点击显示所有文件按钮，即可看到生成后的新文件
右键新的文件夹，包括在项目中
由于是新生成的代码，所以才配置新的菜单
如上图，在Web项目中的wwwroot/Config/SystemMenu.config中配置菜单，模仿原有菜单即可，其中Url是指页面的路径，Permission是指若需要访问此菜单需要的权限（对应权限配置），若没有此权限，则菜单也中不会显示此菜单，修改完成后重新编译生成（权限相关模块进行了缓存，重新生成会清缓存），重新运行即可看到新的项目菜单如下：
整个代码生成过程，无需编写代码即可完成一张表的CRUD，当然需要根据具体业务中进行相应的修改，本次示例中字段比较少，但是当一张表的字段很多时，那么此功能能够将开发效率提高几个档次。
-
管理员登录
若要使用登录功能，请将GlobalSwitch中的RunModel改为RunModel.Publish
默认超级管理员账号为：Admin
密码为：123456
-
系统用户管理
管理系统登录的用户
菜单：系统=>系统管理=>用户管理，如下页面
点击右侧设置权限，可以设置用户权限，详情见<权限管理>模块
具体权限相关配置见权限管理模块
-
系统角色管理
管理系统角色，角色是权限的载体，合理分配角色有利于权限管理
菜单：系统=>系统管理=>角色管理
操作中可以设置角色的权限，详情见<权限管理>模块
-
权限管理
一般情况下，后台管理系统多少会涉及权限管理，因此本框架提供了一个灵活、高效、简洁的权限管理系统。
首先，权限分为两种，即操作权限和数据权限，其中操作权限报货系统用户权限和AppId权限，系统用户权限就是指操作用户具备哪些权限，而当对外提供Api接口时，为了保证接口的安全性（若不在意可忽略），通常会提供接口签名算法，其中AppId和AppSecret是必备的，通过对AppId设置权限，即可控制接口的权限。数据权限比较复杂，若采用纯SQL方式，那么会更加复杂，本框架全程采用EF作为ORM框架，通过对IQueryable<T>进行过滤，即可完成数据权限控制。
用户权限：若对每个用户都设置对应的权限，那么工作量无疑是十分巨大的，因此引入了角色的概念，角色是权限的集合载体，那么属于此角色的用户就继承了角色的权限，当然某些特殊用户需要拥有自己的不属于角色的特殊权限，因此最终用户拥有的权限就是自己的权限和所属角色权限的并集。
权限使用：
权限定义：
如上图，在Permission.config中定义了各个权限
权限配置：
在系统用户管理和系统角色管理中可以设置用户和角色的权限，把需要的权限勾选即可。
权限使用：
如上图所示，在需要控制权限的页面中，调用方法：PermissionManage.OperatorHasPermissionValue("sysuser.manage")
这个方法是判断操作者用户是否含有sysuser.manage权限值，其中sysuser是指Permission.config中定义的module的value属性，manage是指permission中的value属性，用.连接即是最终权限值。
更详细的使用方式，请参考源代码。
-
接口秘钥管理
菜单：系统=>系统管理=>接口秘钥管理
-
系统日志
菜单：系统=>系统管理=>系统日志
-
结语
欢迎使用本框架，若觉得不错，请比心
Github:https://github.com/Coldairarrow，请Statrt
博客园：https://www.cnblogs.com/coldairarrow/
QQ群：373144077
本人将会对这个快速开发框架不断完善与维护，希望能够帮助到各位
若遇到任何问题或需要技术支持，请联系我。
---------------------学习永无止境，技术永无上限，代码就是艺术-----------------------
EasyWcf------无需配置，无需引用，动态绑定，轻松使用
设计原则：万物皆对象
前言：在上一篇的0配置使用Wcf中，虽然使用已经很方便了，但是对于最求极致简洁得人来说（比如我），客户端需要通过手动引用服务才能够调用服务接口，那么有没有办法能够绕过手动引用这一步，并且直接通过调用地址使用呢？答案肯定是有的，不然我这篇文章就毫无意义了，而我是从来不做无意义之事，人狠话不多，下面介绍如何简单、优雅、高效的使用Wcf
正文：
首先需要引入框架，框架代码以及Demo源码在最后的Git地址中！
服务端：
定义接口：
using System.ServiceModel;
namespace WcfServer
{
[ServiceContract]
public interface IMyService
{
[OperationContract]
string Hello();
}
}
实现接口：
namespace WcfServer
{
public class MyService : IMyService
{
public string Hello()
{
return "Hello World!";
}
}
}
这里只是简单输出Hello World，别的操作只需要仿造即可！
服务端启动：
using Coldairarrow.Util.Wcf;
using System;
namespace WcfServer
{
class Program
{
static void Main(string[] args)
{
WcfHost<MyService, IMyService> wcfHost = new WcfHost<MyService, IMyService>("http://localhost:14725", "http://localhost:14725/mex");
wcfHost.HandleHostOpened = new Action<object, EventArgs>((obj, tar) =>
{
Console.WriteLine("服务已启动！");
});
wcfHost.StartHost();
while (Console.ReadLine() != "quit")
{
}
}
}
}
服务端与上次的使用没多大区别
注意：服务端启动必须要以管理员身份运行！
客户端：
using Coldairarrow.Util.Wcf;
using System;
using WcfServer;
namespace WcfClient
{
class Program
{
static void Main(string[] args)
{
var client = WcfClientFactory.CreateClientByUrl<IMyService>("http://localhost:14725/MyService");
var data = client.Hello();
Console.WriteLine(data);
Console.ReadKey();
}
}
}
客户端的使用不需要再从地址引用服务了，直接通过调用WcfClientFactory.CreateClientByUrl方法就可以返回操作接口，其中需要传入泛型接口类，也就是服务端中的IMyService。
服务端运行后，客户端直接运行即可！
运行截图如下：
服务端截图：
客户端截图：
可以看到，使用起来十分地简单方便，可以极大的提高开发效率！
老规矩，全部源码及Demo在GitHub：https://github.com/Coldairarrow/EasyWcf
大家用得爽了别忘了点星星哦~~~
分割线------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
经过了差不多半年，毕业设计也终于完成了，我的毕设是后台快速开发框架，不出意外这个框架会永远伴随着我，我也会一直完善它，希望它能够在我的职业生涯中发放光彩！
毕设虽然完成了，但是探索技术的步伐是永远不会停止的！大家一起加油~~~
END
C# .NET 0配置使用Wcf(半成品)
设计原则：万物皆对象
背景：微软提供了一套强大的通信框架Wcf，了解请看百度百科：ttps://baike.baidu.com/item/Wcf/7374854?fr=aladdin
虽然这套通信框架很强大，但是配置起来也不简单，因此导致很多人望而却步（包括我），我这人向来不喜欢麻烦，喜欢简单，最好就是给我一个对象，告诉我怎么传参就使用是最爽的，我相信应该有很多人跟我一样的想法，因此，这篇文章应运而生，没错，就是零配置使用Wcf，下面我会详细道来。
正文：
1、核心类库，注意，需要引用程序集
System.ServiceModel
WcfHost.cs
using System;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.Threading.Tasks;
namespace Coldairarrow.Util.Wcf
{
/// <summary>
/// Wcf服务代码控制类（必须开启管理员权限）
/// </summary>
/// <typeparam name="Service">服务处理</typeparam>
/// <typeparam name="IService">服务接口</typeparam>
public class WcfHost<Service,IService>
{
#region 构造函数
/// <summary>
/// 构造函数
/// </summary>
/// <param name="baseUrl">http基地址（服务器真实地址）,默认为:http://127.0.0.1:14725/ </param>
/// <param name="httpGetUrl">http获取服务引用的地址（服务器真实地址）,默认为:http://127.0.0.1:14725/mex </param>
public WcfHost(string baseUrl= "http://127.0.0.1:14725/", string httpGetUrl= "http://127.0.0.1:14725/mex")
{
_serviceHost = new ServiceHost(typeof(Service), new Uri(baseUrl));
//ServiceEndPoint 终结点 包含Address地址 Binding绑定 Contracts契约 简称ABC
_serviceHost.AddServiceEndpoint(typeof(IService), new WSHttpBinding(), typeof(Service).Name);
//添加服务终结点
if (_serviceHost.Description.Behaviors.Find<ServiceMetadataBehavior>() == null)
{
//判断是否在配置文件中定义了元数据终结点
ServiceMetadataBehavior metaData = new ServiceMetadataBehavior();
metaData.HttpGetEnabled = true;
metaData.HttpGetUrl = new Uri(httpGetUrl);
_serviceHost.Description.Behaviors.Add(metaData);//添加元数据终结点
}
}
#endregion
#region 私有成员
private ServiceHost _serviceHost;
#endregion
#region 外部接口
/// <summary>
/// 开始Wcf服务
/// </summary>
public void StartHost()
{
Task task = new Task(() =>
{
try
{
if (HandleHostOpened != null)
_serviceHost.Opened += new EventHandler(HandleHostOpened);
if (_serviceHost.State != CommunicationState.Opened)
{
_serviceHost.Open();
}
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
});
task.Start();
}
#endregion
#region 事件处理
/// <summary>
/// 当Wcf服务开启后执行
/// </summary>
public Action<object, EventArgs> HandleHostOpened { get; set; }
/// <summary>
/// 异常处理
/// </summary>
public Action<Exception> HandleException { get; set; }
#endregion
}
}
2、服务端使用：
服务接口定义：
IService.cs
using System.ServiceModel;
namespace _01.WcfServer
{
/// <summary>
/// 对外提供的接口规范，必须要ServiceContract特性
/// </summary>
[ServiceContract]
public interface IService
{
/// <summary>
/// 对外提供的接口方法，必须OperationContract特性，方法不能重载
/// </summary>
/// <returns></returns>
[OperationContract]
string Hello();
}
}
服务接口实现：
Service.cs
namespace _01.WcfServer
{
/// <summary>
/// 接口具体实现类
/// </summary>
public class Service : IService
{
/// <summary>
/// 方法具体实现
/// </summary>
/// <returns></returns>
public string Hello()
{
return "Hello World";
}
}
}
服务端运行：注意，必须以管理员权限运行
Program.cs
using Coldairarrow.Util.Wcf;
using System;
namespace _01.WcfServer
{
class Program
{
static void Main(string[] args)
{
//创建Wcf服务对象，泛型参数Service为实现类，IService为服务接口
//第一个参数baseUrl为服务基地址（必须为真实地址）
//第二个参数httpGetUrl为服务引用地址（必须为真实地址）,也就是客户端添加服务引用时用的地址
WcfHost<Service, IService> wcfHost = new WcfHost<Service, IService>("http://localhost:14725", "http://localhost:14725/mex");
//当Wcf服务开启后执行的事件
wcfHost.HandleHostOpened = new Action<object, EventArgs>((obj, tar) =>
{
Console.WriteLine("服务已启动！");
});
//开始Wcf服务
wcfHost.StartHost();
while(Console.ReadLine()!="quit")
{
}
}
}
}
客户端使用：
Program.cs
using System;
namespace _02.WcfClient
{
class Program
{
static void Main(string[] args)
{
//ServiceReference1为引用时自定义的命名空间
//ServiceClient为具体实现类，Service为类名，Client为后缀
//可以在很多地方使用，比如控制台，Winform,ASP.NET网站等，把它当做一个类库就很好理解了66666
ServiceReference1.ServiceClient client = new ServiceReference1.ServiceClient();
//调用Service提供的Hello方法,Wcf服务端必须运行
var data = client.Hello();
Console.WriteLine(data);
Console.ReadKey();
}
}
}
详细使用步骤：
1、运行Wcf服务端，必须以管理员权限
2、打开浏览器，测试Wcf是否成功开启
3、客户端引用服务
右键引用，引用服务，输入服务地址（即Wcf初始化时第二个参数）
3、客户端代码调用
2、客户端成功运行
总结：
全程实现真正的0配置搭建了Wcf服务，满不满意，意不意外，惊不惊喜，爽不爽~~
最后，惯例，全部代码代码在GitHub,欢迎大家点赞~
https://github.com/Coldairarrow/Wcf
C# .NET Socket 简单实用框架
背景：
首先向各位前辈，大哥哥小姐姐问一声好~
这是我第一次写博客，目前为一个即将步入大四的学生，上学期在一家公司实习了半年，后期发现没有动力，而且由于薪水问题（废话嘛），于是跳槽到这家新的公司。
说到Socket，想必大家都或多或少有所涉及，从最初的计算机网络课程，讲述了tcp协议，而Socket就是对协议的进一步封装，使我们开发人员能够更加容易轻松的进行软件之间的通信。
这个星期刚好接受一个共享车位锁的项目，需要使用Socket与硬件进行通信控制，说白了也就是给锁发送指令，控制其打开或者关闭，再就是对App开放操作接口，使其方便测试以及用户的使用。这其中核心就是Socket的使用，再开发出这个功能之后，我发现使用起来很不方便，于是耗时2天抽象其核心功能并封装成框架，最后使用这个框架将原来的项目重构并上线，极大的提高了软件的可拓展性，健壮性，容错率。
个人坚信的原则：万物皆对象
好了，不废话了，下面进入正文
正文：
1、首先简单讲下C#中Socket的简单使用。
第一步：服务端监听某个端口
第二步：客户端向服务端地址和端口发起Socket连接请求
第三步：服务端收到连接请求后创建Socket连接，并维护这个连接队列。
第四步：客户端和服务端已经建立双工通信（即双向通信），客户端和服务端可以轻松方便的给彼此发送信息。
至于简单使用的具体实现代码全部被我封装到项目中了，如果需要学习简单的实现，可以看我的源码，也可以自行百度，有很多的教程
2、核心，框架的使用
其实，说其为框架，可能有点牵强，因为每个人对框架都有自己的理解，但是类库和框架又有什么本质区别呢？全部都是代码~哈哈，扯远了
首先，空说无凭，先放上所有的代码：
服务端源文件：
SocketServer.cs
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
namespace Coldairarrow.Util.Sockets
{
/// <summary>
/// Socket服务端
/// </summary>
public class SocketServer
{
#region 构造函数
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">监听的IP地址</param>
/// <param name="port">监听的端口</param>
public SocketServer(string ip, int port)
{
_ip = ip;
_port = port;
}
/// <summary>
/// 构造函数,监听IP地址默认为本机0.0.0.0
/// </summary>
/// <param name="port">监听的端口</param>
public SocketServer(int port)
{
_ip = "0.0.0.0";
_port = port;
}
#endregion
#region 内部成员
private Socket _socket = null;
private string _ip = "";
private int _port = 0;
private bool _isListen = true;
private void StartListen()
{
try
{
_socket.BeginAccept(asyncResult =>
{
try
{
Socket newSocket = _socket.EndAccept(asyncResult);
//马上进行下一轮监听,增加吞吐量
if (_isListen)
StartListen();
SocketConnection newClient = new SocketConnection(newSocket, this)
{
HandleRecMsg = HandleRecMsg == null ? null : new Action<byte[], SocketConnection, SocketServer>(HandleRecMsg),
HandleClientClose = HandleClientClose == null ? null : new Action<SocketConnection, SocketServer>(HandleClientClose),
HandleSendMsg = HandleSendMsg == null ? null : new Action<byte[], SocketConnection, SocketServer>(HandleSendMsg),
HandleException = HandleException == null ? null : new Action<Exception>(HandleException)
};
newClient.StartRecMsg();
ClientList.AddLast(newClient);
HandleNewClientConnected?.Invoke(this, newClient);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}, null);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}
#endregion
#region 外部接口
/// <summary>
/// 开始服务，监听客户端
/// </summary>
public void StartServer()
{
try
{
//实例化套接字（ip4寻址协议，流式传输，TCP协议）
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//创建ip对象
IPAddress address = IPAddress.Parse(_ip);
//创建网络节点对象包含ip和port
IPEndPoint endpoint = new IPEndPoint(address, _port);
//将 监听套接字绑定到 对应的IP和端口
_socket.Bind(endpoint);
//设置监听队列长度为Int32最大值(同时能够处理连接请求数量)
_socket.Listen(int.MaxValue);
//开始监听客户端
StartListen();
HandleServerStarted?.Invoke(this);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}
/// <summary>
/// 所有连接的客户端列表
/// </summary>
public LinkedList<SocketConnection> ClientList { get; set; } = new LinkedList<SocketConnection>();
/// <summary>
/// 关闭指定客户端连接
/// </summary>
/// <param name="theClient">指定的客户端连接</param>
public void CloseClient(SocketConnection theClient)
{
theClient.Close();
}
#endregion
#region 公共事件
/// <summary>
/// 异常处理程序
/// </summary>
public Action<Exception> HandleException { get; set; }
#endregion
#region 服务端事件
/// <summary>
/// 服务启动后执行
/// </summary>
public Action<SocketServer> HandleServerStarted { get; set; }
/// <summary>
/// 当新客户端连接后执行
/// </summary>
public Action<SocketServer, SocketConnection> HandleNewClientConnected { get; set; }
/// <summary>
/// 服务端关闭客户端后执行
/// </summary>
public Action<SocketServer, SocketConnection> HandleCloseClient { get; set; }
#endregion
#region 客户端连接事件
/// <summary>
/// 客户端连接接受新的消息后调用
/// </summary>
public Action<byte[], SocketConnection, SocketServer> HandleRecMsg { get; set; }
/// <summary>
/// 客户端连接发送消息后回调
/// </summary>
public Action<byte[], SocketConnection, SocketServer> HandleSendMsg { get; set; }
/// <summary>
/// 客户端连接关闭后回调
/// </summary>
public Action<SocketConnection, SocketServer> HandleClientClose { get; set; }
#endregion
}
}
using System;
using System.Net.Sockets;
using System.Text;
namespace Coldairarrow.Util.Sockets
{
/// <summary>
/// Socket连接,双向通信
/// </summary>
public class SocketConnection
{
#region 构造函数
public SocketConnection(Socket socket,SocketServer server)
{
_socket = socket;
_server = server;
}
#endregion
#region 私有成员
private readonly Socket _socket;
private bool _isRec=true;
private SocketServer _server = null;
private bool IsSocketConnected()
{
bool part1 = _socket.Poll(1000, SelectMode.SelectRead);
bool part2 = (_socket.Available == 0);
if (part1 && part2)
return false;
else
return true;
}
#endregion
#region 外部接口
/// <summary>
/// 开始接受客户端消息
/// </summary>
public void StartRecMsg()
{
try
{
byte[] container = new byte[1024 * 1024 * 2];
_socket.BeginReceive(container, 0, container.Length, SocketFlags.None, asyncResult =>
{
try
{
int length = _socket.EndReceive(asyncResult);
//马上进行下一轮接受，增加吞吐量
if (length > 0 && _isRec && IsSocketConnected())
StartRecMsg();
if (length > 0)
{
byte[] recBytes = new byte[length];
Array.Copy(container, 0, recBytes, 0, length);
//处理消息
HandleRecMsg?.Invoke(recBytes, this, _server);
}
else
Close();
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
Close();
}
}, null);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
Close();
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="bytes">数据字节</param>
public void Send(byte[] bytes)
{
try
{
_socket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, asyncResult =>
{
try
{
int length = _socket.EndSend(asyncResult);
HandleSendMsg?.Invoke(bytes, this, _server);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}, null);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}
/// <summary>
/// 发送字符串（默认使用UTF-8编码）
/// </summary>
/// <param name="msgStr">字符串</param>
public void Send(string msgStr)
{
Send(Encoding.UTF8.GetBytes(msgStr));
}
/// <summary>
/// 发送字符串（使用自定义编码）
/// </summary>
/// <param name="msgStr">字符串消息</param>
/// <param name="encoding">使用的编码</param>
public void Send(string msgStr,Encoding encoding)
{
Send(encoding.GetBytes(msgStr));
}
/// <summary>
/// 传入自定义属性
/// </summary>
public object Property { get; set; }
/// <summary>
/// 关闭当前连接
/// </summary>
public void Close()
{
try
{
_isRec = false;
_socket.Disconnect(false);
_server.ClientList.Remove(this);
HandleClientClose?.Invoke(this, _server);
_socket.Close();
_socket.Dispose();
GC.Collect();
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}
#endregion
#region 事件处理
/// <summary>
/// 客户端连接接受新的消息后调用
/// </summary>
public Action<byte[], SocketConnection, SocketServer> HandleRecMsg { get; set; }
/// <summary>
/// 客户端连接发送消息后回调
/// </summary>
public Action<byte[], SocketConnection, SocketServer> HandleSendMsg { get; set; }
/// <summary>
/// 客户端连接关闭后回调
/// </summary>
public Action<SocketConnection, SocketServer> HandleClientClose { get; set; }
/// <summary>
/// 异常处理程序
/// </summary>
public Action<Exception> HandleException { get; set; }
#endregion
}
}
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
namespace Coldairarrow.Util.Sockets
{
/// <summary>
/// Socket客户端
/// </summary>
public class SocketClient
{
#region 构造函数
/// <summary>
/// 构造函数,连接服务器IP地址默认为本机127.0.0.1
/// </summary>
/// <param name="port">监听的端口</param>
public SocketClient(int port)
{
_ip = "127.0.0.1";
_port = port;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ip">监听的IP地址</param>
/// <param name="port">监听的端口</param>
public SocketClient(string ip, int port)
{
_ip = ip;
_port = port;
}
#endregion
#region 内部成员
private Socket _socket = null;
private string _ip = "";
private int _port = 0;
private bool _isRec=true;
private bool IsSocketConnected()
{
bool part1 = _socket.Poll(1000, SelectMode.SelectRead);
bool part2 = (_socket.Available == 0);
if (part1 && part2)
return false;
else
return true;
}
/// <summary>
/// 开始接受客户端消息
/// </summary>
public void StartRecMsg()
{
try
{
byte[] container = new byte[1024 * 1024 * 2];
_socket.BeginReceive(container, 0, container.Length, SocketFlags.None, asyncResult =>
{
try
{
int length = _socket.EndReceive(asyncResult);
//马上进行下一轮接受，增加吞吐量
if (length > 0 && _isRec && IsSocketConnected())
StartRecMsg();
if (length > 0)
{
byte[] recBytes = new byte[length];
Array.Copy(container, 0, recBytes, 0, length);
//处理消息
HandleRecMsg?.Invoke(recBytes, this);
}
else
Close();
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
Close();
}
}, null);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
Close();
}
}
#endregion
#region 外部接口
/// <summary>
/// 开始服务，连接服务端
/// </summary>
public void StartClient()
{
try
{
//实例化 套接字 （ip4寻址协议，流式传输，TCP协议）
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//创建 ip对象
IPAddress address = IPAddress.Parse(_ip);
//创建网络节点对象 包含 ip和port
IPEndPoint endpoint = new IPEndPoint(address, _port);
//将 监听套接字 绑定到 对应的IP和端口
_socket.BeginConnect(endpoint, asyncResult =>
{
try
{
_socket.EndConnect(asyncResult);
//开始接受服务器消息
StartRecMsg();
HandleClientStarted?.Invoke(this);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}, null);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="bytes">数据字节</param>
public void Send(byte[] bytes)
{
try
{
_socket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, asyncResult =>
{
try
{
int length = _socket.EndSend(asyncResult);
HandleSendMsg?.Invoke(bytes, this);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}, null);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}
/// <summary>
/// 发送字符串（默认使用UTF-8编码）
/// </summary>
/// <param name="msgStr">字符串</param>
public void Send(string msgStr)
{
Send(Encoding.UTF8.GetBytes(msgStr));
}
/// <summary>
/// 发送字符串（使用自定义编码）
/// </summary>
/// <param name="msgStr">字符串消息</param>
/// <param name="encoding">使用的编码</param>
public void Send(string msgStr, Encoding encoding)
{
Send(encoding.GetBytes(msgStr));
}
/// <summary>
/// 传入自定义属性
/// </summary>
public object Property { get; set; }
/// <summary>
/// 关闭与服务器的连接
/// </summary>
public void Close()
{
try
{
_isRec = false;
_socket.Disconnect(false);
HandleClientClose?.Invoke(this);
}
catch (Exception ex)
{
HandleException?.Invoke(ex);
}
}
#endregion
#region 事件处理
/// <summary>
/// 客户端连接建立后回调
/// </summary>
public Action<SocketClient> HandleClientStarted { get; set; }
/// <summary>
/// 处理接受消息的委托
/// </summary>
public Action<byte[], SocketClient> HandleRecMsg { get; set; }
/// <summary>
/// 客户端连接发送消息后回调
/// </summary>
public Action<byte[], SocketClient> HandleSendMsg { get; set; }
/// <summary>
/// 客户端连接关闭后回调
/// </summary>
public Action<SocketClient> HandleClientClose { get; set; }
/// <summary>
/// 异常处理程序
/// </summary>
public Action<Exception> HandleException { get; set; }
#endregion
}
}
上面放上的是框架代码，接下来介绍下如何使用
首先，服务端使用方式：
using Coldairarrow.Util.Sockets;
using System;
using System.Text;
namespace Console_Server
{
class Program
{
static void Main(string[] args)
{
//创建服务器对象，默认监听本机0.0.0.0，端口12345
SocketServer server = new SocketServer(12345);
//处理从客户端收到的消息
server.HandleRecMsg = new Action<byte[], SocketConnection, SocketServer>((bytes, client, theServer) =>
{
string msg = Encoding.UTF8.GetString(bytes);
Console.WriteLine($"收到消息:{msg}");
});
//处理服务器启动后事件
server.HandleServerStarted = new Action<SocketServer>(theServer =>
{
Console.WriteLine("服务已启动************");
});
//处理新的客户端连接后的事件
server.HandleNewClientConnected = new Action<SocketServer, SocketConnection>((theServer, theCon) =>
{
Console.WriteLine($@"一个新的客户端接入，当前连接数：{theServer.ClientList.Count}");
});
//处理客户端连接关闭后的事件
server.HandleClientClose = new Action<SocketConnection, SocketServer>((theCon, theServer) =>
{
Console.WriteLine($@"一个客户端关闭，当前连接数为：{theServer.ClientList.Count}");
});
//处理异常
server.HandleException = new Action<Exception>(ex =>
{
Console.WriteLine(ex.Message);
});
//服务器启动
server.StartServer();
while (true)
{
Console.WriteLine("输入:quit，关闭服务器");
string op = Console.ReadLine();
if (op == "quit")
break;
}
}
}
}
客户端使用方式：
using Coldairarrow.Util.Sockets;
using System;
using System.Text;
namespace Console_Client
{
class Program
{
static void Main(string[] args)
{
//创建客户端对象，默认连接本机127.0.0.1,端口为12345
SocketClient client = new SocketClient(12345);
//绑定当收到服务器发送的消息后的处理事件
client.HandleRecMsg = new Action<byte[], SocketClient>((bytes, theClient) =>
{
string msg = Encoding.UTF8.GetString(bytes);
Console.WriteLine($"收到消息:{msg}");
});
//绑定向服务器发送消息后的处理事件
client.HandleSendMsg = new Action<byte[], SocketClient>((bytes, theClient) =>
{
string msg = Encoding.UTF8.GetString(bytes);
Console.WriteLine($"向服务器发送消息:{msg}");
});
//开始运行客户端
client.StartClient();
while (true)
{
Console.WriteLine("输入:quit关闭客户端，输入其它消息发送到服务器");
string str = Console.ReadLine();
if (str == "quit")
{
client.Close();
break;
}
else
{
client.Send(str);
}
}
}
}
}
最后运行测试截图：
总结：
其最方便之处在于，将如何创建连接封装掉，使用人员只需关注连接后发送什么数据，接收到数据后应该如何处理，等等其它的很多事件的处理，这其中主要依托于匿名委托的使用，Lambda表达式的使用。
框架里面主要使用了异步通讯，以及如何控制连接，详细我就不多说了，大家应该一看就懂，我只希望能给大家带来便利，最后大家有任何问题、意见、想法，都可以给我留言。
最后，附上所有源码项目地址，若觉得有一定价值，还请点赞~
GitHub地址：https://github.com/Coldairarrow/Sockets
C# .NET 0命令行安装Windows服务程序
设计原则：万物皆对象
背景：在我的项目中，即需要与硬件通过Socket连接通讯，又需要给App提供Wcf服务操作接口，虽然都完成了，但是却是一个控制台（虽然我很喜欢控制台，因为它简单易用），把它放到服务器运行，总有一个黑乎乎的窗口，总感觉不雅（原谅我的强迫症）。于是各种百度谷歌如何创建运行WIndows服务程序，就像SqlServer数据那样在后台默默运行奉献就可以了。
但是，很多都是那么的麻烦，需要批处理什么的，而我这个人向来喜欢简洁，于是便设计了这么个Windows服务辅助类，没错，就是0命令。
正文：
1、类库源码我就不放了，最后都放到GitHub上
2、使用方法：
using Coldairarrow.Util.WindowsService;
using System;
namespace WindowsServiceTest
{
class Program
{
public static void Main(string[] argc)
{
//创建服务容器，第一个参数为指定服务名，第二个参数为主函数入口的参数argc
WindowsServiceContainer serviceContainer = new WindowsServiceContainer("A_Test_Service", argc);
//服务启动时执行的事件，即可以看做控制台的主函数Main即可
serviceContainer.HandleOnStart = new Action<string[]>(args =>
{
//可以在这里添加你需要服务干的事情，比如创建Socket通讯，Wcf服务，balabala.........
//让它在后台默默地工作把~~~~~~~~~~
});
//处理日志的事件
serviceContainer.HandleLog = new Action<string>(log =>
{
Console.WriteLine(log);
});
//处理异常的事件
serviceContainer.HandleException = new Action<Exception>(ex =>
{
Console.WriteLine(ex.Message);
});
//开始运行服务
serviceContainer.Start();
}
}
}
直接运行控制台即可：
选择1进行安装服务：
没错，你可以看见服务已经成功运行了！！！，是不是很假单？
选择2进行服务卸载：
总结：
通过对服务操作一系列的封装，使将控制台程序变成服务程序非常的简单，不需要任何的批处理命令，只需要简单的几行代码即可，感觉很爽的请点赞！
老规矩，GitHub地址：
