anmei1912

线程安全使用（四） [.NET] 简单接入微信公众号开发：实现自动回复 [C#]C#中字符串的操作自行实现比dotcore/dotnet更方便更高性能的对象二进制序列化自已动手做高性能消息...

线程安全使用（四）

这是时隔多年第四篇，主要是因为身在东软受内网限制，好多文章就只好发到东软内部网站，懒的发到外面，现在一点点把在东软写的文章给转移出来。

这里主要讲解下CancellationTokenSource，CancellationTokenSource是用于取消线程，具体使用起来有点另类：首先定义实体，然后将其下的属性ToKen传递给线程，当需要取消线程时，调用下Cancel()方法。例子我依然采用了MSDN的例子,但我做了一些修改，这个例子虽然看起来挺复杂，但还是记录了许多内容。

由于不好理解，我就粗略讲解下：

Task fTask = factory.ContinueWhenAll(tasks.ToArray(), 上面是创建任务，创建10个线程，并且线程中增加了判断，如果随即数等于0就取消该线程。

再介绍下factory.ContinueWhenAll，他包含两个参数Task[] tasks,
Action continuationAction。MSDN的解释是：

ContinueWhenAll 方法执行 continuationAction 委托，在 tasks 数组的所有任务完成后，无论它们的完成状态。

MSDN上就这个翻译的还不错，其他的基本可以无视了。。。

继续看代码，代码中增加了try catch，这是为什么呢，看下ContinueWhenAll英文解释：

The exception that is thrown when the tasks array is empty

这里千万不能看中文解释，不然你会凌乱的。看了英文解释就懂了，让任务为空就抛异常。

那么为什么任务为空呢，因为任务已经被取消了啊，所以为空了。具体代码如下。

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
    public static void Main()
    {
        // Define the cancellation token.
        CancellationTokenSource source = new CancellationTokenSource();
        CancellationToken token = source.Token;
        Random rnd = new Random();
        Object lockObj = new Object();
        List> tasks = new List>();
        TaskFactory factory = new TaskFactory(token);
        for (int taskCtr = 0; taskCtr <= 10; taskCtr++)
        {
            int iteration = taskCtr + 1;
            tasks.Add(factory.StartNew(() =>
            {
                int value;
                int[] values = new int[10];
                for (int ctr = 1; ctr <= 10; ctr++)
                {
                    lock (lockObj)
                    {
                        value = rnd.Next(0, 101);
                    }
                    if (value == 0)
                    {
                        source.Cancel();
                        Console.WriteLine("Cancelling at task {0}", iteration);
                        break;
                    }
                   
                    values[ctr - 1] = value;
                }
                Console.WriteLine("NO Cancel at task {0}", iteration);
                return values;
            }, token));
        }
        try
        {
            Task fTask = factory.ContinueWhenAll(tasks.ToArray(),
                                                         (results) =>
                                                         {
                                                             Console.WriteLine("Calculating overall mean...");
                                                             long sum = 0;
                                                             int n = 0;
                                                             foreach (var t in results)
                                                             {
                                                                 foreach (var r in t.Result)
                                                                 {
                                                                     sum += r;
                                                                     n++;
                                                                 }
                                                             }
                                                             return sum / (double)n;
                                                         }, token);
            Console.WriteLine("The mean is {0}.", fTask.Result);
        }
        catch (AggregateException ae)
        {
            foreach (Exception e in ae.InnerExceptions)
            {
                if (e is TaskCanceledException)
                    Console.WriteLine("Unable to compute mean: {0}",
                                      ((TaskCanceledException)e).Message);
                else
                    Console.WriteLine("Exception: " + e.GetType().Name);
            }
        }
        Console.ReadLine();
        
    }
}

显示结果图片，每次的结果都不一样的，所以我也是运行了好几次，看这个结果会发现一件事，线程只执行了两个，即当线程2中调用Cancel后，其他线程也被取消了。

[.NET] 简单接入微信公众号开发：实现自动回复

简单接入微信公众号开发：实现自动回复

一、前提

　　先申请微信公众号的授权，找到或配置几个关键的信息（开发者ID、开发者密码、IP白名单、令牌和消息加解密密钥等）。

二、基本配置信息解读

　　开发者ID：固定的；

　　开发者密码：自己扫一下就可以看到；

　　IP白名单：设置自己配置服务器的地址；

　　服务器地址（URL）：稍后详解；

　　令牌：随便写，按规则；

　　消息加解密密钥：随便写，或者随机生成；

三、配置服务器地址（URL）

　　服务器地址（URL）应该怎么配置呢？图片上的配置的地址是：http://www.nidie.com.cn/wechat ，那么它对应的控制器应该是怎么样子的呢？

　　在这里，我使用了第三方的包，需要通过 Nuget 来安装：

　　接下来新建一个 WeChatController.cs:

using System.Threading.Tasks;
using System.Web.Mvc;
using Senparc.Weixin.MP;
using Senparc.Weixin.MP.Entities.Request;
using Senparc.Weixin.MP.MvcExtension;
using Wen.MvcDemo.Application.WeChat.MessageHandlers.CustomMessageHandlers;
using Wen.MvcDemo.Infrastructure.Configuration;

namespace Wen.MvcDemo.Web.Controllers
{
    /// 
    /// 微信
    /// 
    public class WeChatController : Controller
    {
        #region private static field

        private static readonly string AppId = ApplicationSettingsFactory.GetApplicationSettings().WeChatAppId;

        private static readonly string EncodingAesKey = ApplicationSettingsFactory.GetApplicationSettings().WeChatEncodingAesKey;

        private static readonly string Token = ApplicationSettingsFactory.GetApplicationSettings().WeChatToken;

        #endregion private static field

        /// 
        /// 微信后台验证地址
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        [HttpGet]
        public ActionResult Index(string signature, string timestamp, string nonce, string echostr)
        {
            return Content(echostr);
        }

        /// 
        /// 处理用户发送消息后
        /// 
        /// 
        /// 
        [HttpPost]
        public async Task Index(PostModel postModel)
        {
            //校验签名
            if (!CheckSignature.Check(postModel.Signature, postModel.Timestamp, postModel.Nonce, Token))
                return new WeixinResult("参数错误！");

            postModel.AppId = AppId;
            postModel.EncodingAESKey = EncodingAesKey;
            postModel.Token = Token;

            //接收消息，自定义 MessageHandler，对微信请求进行处理
            var messageHandler = new CustomMessageHandler(Request.InputStream, postModel);

            //执行微信处理过程
            await messageHandler.ExecuteAsync();
            //返回处理结果
            return new FixWeixinBugWeixinResult(messageHandler);
        }
    }
}

　　代码分析：

　　里面主要包含了三个静态字段和两个 Index 方法。

　　其中静态字段对应的就是基本配置信息里面对应的几个参数，平常都是写入配置文件中来进行读取。

　　其中一个标识特性为 HttpGet 的 Index 方法，它是用来通过服务器地址（URL）验证的，当你成功部署到你的服务器后，再点击提交认证就可以通过了。注意的是，需要将代码先提交到服务器，再进行提交确认。

　　可能你看到该方法好像只返回 return Content(echostr); 这么简单的代码感到质疑：这能行吗？“我”记得官方文档好像要调用很复杂的方法进行校验才行的！？

　　上图就是官方文档，但是我只关心通过配置提交认证，也就是我用红圈着色的部分，即原样返回 echostr 参数内容即可。

　　第二个是实现 Post 请求的 Index 方法，在这里我进行了签名校验（也就是上图文档的校验逻辑），因为使用了第三方库，我们知道传哪些参数过去就可以了，签名通过后就是读取请求信息并进行后续处理的步骤了。

四、请求处理

　　在上面的处理请求信息的代码中，我自定义了一个类 CustomMessageHandler 来处理消息。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using Senparc.Weixin.MP.AppStore;
using Senparc.Weixin.MP.AppStore.Utility;
using Senparc.Weixin.MP.Entities;
using Senparc.Weixin.MP.Entities.Request;
using Senparc.Weixin.MP.MessageHandlers;

namespace Wen.MvcDemo.Application.WeChat.MessageHandlers.CustomMessageHandlers
{
    /// 
    /// 自定义消息处理
    /// 
    public class CustomMessageHandler : MessageHandler
    {
        public CustomMessageHandler(Stream inputStream, PostModel postModel = null, int maxRecordCount = 0, DeveloperInfo developerInfo = null) : base(inputStream, postModel, maxRecordCount, developerInfo)
        {
        }

        public CustomMessageHandler(XDocument requestDocument, PostModel postModel = null, int maxRecordCount = 0, DeveloperInfo developerInfo = null) : base(requestDocument, postModel, maxRecordCount, developerInfo)
        {
        }

        public CustomMessageHandler(RequestMessageBase requestMessageBase, PostModel postModel = null, int maxRecordCount = 0, DeveloperInfo developerInfo = null) : base(requestMessageBase, postModel, maxRecordCount, developerInfo)
        {
        }

        /// 
        /// 默认
        /// 
        /// 
        /// 
        public override IResponseMessageBase DefaultResponseMessage(IRequestMessageBase requestMessage)
        {
            var responseMessage = base.CreateResponseMessage(); //ResponseMessageText也可以是News等其他类型
            responseMessage.Content = $"您好，目前使用的微信公众号仍处于开发阶段，现已接入了【图灵机器人】，您可以尝试和他（她）交流。";
            return responseMessage;
        }
    }
}

　　CustomMessageHandler 类继承了 MessageHandler 类，然后重写了 DefaultResponseMessage() 方法，返回固定的文本值。base.CreateResponseMessage() 方法可以返回多种不同类型的结果值，如：

ResponseMessageText - 对应文本消息

ResponseMessageNews - 对应图文消息

ResponseMessageMusic - 对应音乐消息

ResponseMessageXXX - 其他类型以此类推

　　上述方法只是一种默认的消息处理，我们也可以专门针对不同的请求类型做出不同的回应，比如重写 OnTextRequest()，其它重载需要自己观察基类成员：

        /// 
        /// 文本请求
        /// 
        /// 
        /// 
        public override IResponseMessageBase OnTextRequest(RequestMessageText requestMessage)
        {
            var responseMessage = base.CreateResponseMessage();
            responseMessage.Content = $"您刚才发送的文字信息是：{requestMessage.Content}。";  //\r\n用于换行，requestMessage.Content即用户发过来的文字内容
            return responseMessage;
        }

　　因为在继承 MessageHandler 类的同时，我创建了一个 CustomMessageContext 自定义消息上下文的类，该类内容如下，并没有包含其它方法，直接继承 MessageContext 即可：

using Senparc.Weixin.Context;
using Senparc.Weixin.MP.Entities;

namespace Wen.MvcDemo.Application.WeChat.MessageHandlers.CustomMessageHandlers
{
    /// 
    /// 自定义消息上下文
    /// 
    public class CustomMessageContext : MessageContext
    {
    }
}

　　这样，就完成了所有代码的编写，现在我们再次把代码部署好之后就可以开始进行测试了。

　　因为我除了部署自己的站点之外，还接入了【图灵机器人】回复，所以你看到了两条信息。

[C#]C#中字符串的操作

1.Replace（替换字符）:
public string Replace(char oldChar,char newChar);在对象中寻找oldChar，如果寻找到，就用newChar将oldChar替换掉。
如：
            string st = "abcdef";
            string newstring = st.Replace('a', 'x');
            Console.WriteLine(newstring);   //即：xbcdef

public string Replace(string oldString,string newString);在对象中寻找oldString，如果寻找到，就用newString将oldString替换掉。
如：
            string st = "abcdef";
            string newstring = st.Replace("abc", "xyz");
            Console.WriteLine(newstring);   //即：xyzdef

2.Remove（删除字符）：
public string Remove(int startIndex);从startIndex位置开始，删除此位置后所有的字符（包括当前位置所指定的字符）。
如：
     string st = "abcdef";
            string newstring = st.Remove(4);
            Console.WriteLine(newstring);  //即：abcd

public string Remove(int startIndex,int count);从startIndex位置开始，删除count个字符。
如：
     string st = "abcdef";
            string newstring = st.Remove(4，1);
            Console.WriteLine(newstring);  //即：abcdf

3.Substring（字符串提取）：
public string Substring(int startIndex);从startIndex位置开始，提取此位置后所有的字符（包括当前位置所指定的字符）。
如：
     string st = "abcdef";
            string newstring = st.Substring(2);
            Console.WriteLine(newstring);  //即：cdef

public string Substring(int startIndex,int count);从startIndex位置开始，提取count个字符。
如：
     string st = "abcdef";
            string newstring = st.Substring(2，2);
            Console.WriteLine(newstring);  //即：cd

4.Trim（清空空格）：
public string Trim ()：将字符串对象包含的字符串两边的空格去掉后返回。
public string Trim ( params char[] trimChars )：从此实例的开始和末尾移除数组中指定的一组字符的所有匹配项。
如：
     string st ="abcdef";
     string newstring = st.Trim(new char[] {'a'});//寻找st字符串中开始与末尾是否有与'a'匹配，如有，将其移除。
     Console.WriteLine(newstring); //即：bcdef
注：如果字符串为"aaaabcdef"，返回依然为bcdef。当移除第一个a时，开始依然为a，继续移除，直到没有。
public string TrimEnd ( params char[] trimChars )：对此实例末尾与指定字符进行匹配，true则移除
public string TrimStart ( params char[] trimChars )：对此实例开始与指定字符进行匹配，true则移除

5.ToLower（转换大小写）
public string ToLower()：将字符串对象包含的字符串中的大写全部转换为小写。

6.IndexOf（获取指定的字符串的开始索引）
public int IndexOf (sring field)：在此实例中寻找field，如果寻找到，返回开始索引，反之，返回-1。
如：
       string st = "abcdef";
            int num=st.IndexOf("bcd");
            Console.WriteLine(num);  //即：1

7.Equals(是否相等)
public bool Equals (string value)：比较调用方法的字符串对象包含字符串和参数给出的对象是否相同，如相同，就返回true，反之，返回false。
如：        string a = "abcdef";
            bool b = a.Equals("bcdef");
            Console.WriteLine(b);//即：false

public bool Equals ( string value, StringComparison comparisonType )：比较调用方法的字符串对象包含字符串和参数给出的对象是否在不区分大小写的情况下相同，如相同，就返回true，反之，返回false,第二个参数将指定区域性、大小写以及比较所用的排序规则.
如：
       string a = "ABCDEF";
            bool b = a.Equals("abcdef",StringComparison.CurrentCultureIgnoreCase);
            Console.WriteLine(b);//即：true

8.Split（拆分）
public string[] Split ( params char[] separator )：根据separator 指定的没有字符分隔此实例中子字符串成为Unicode字符数组， separator可以是不包含分隔符的空数组或空引用。
public string[] Split ( char[] separator, int count )：参数count 指定要返回的子字符串的最大数量。
如：
            string st = "语文|数学|英语|物理";
            string[] split = st.Split(new char[]{'|'},2);
            for (int i = 0; i < split.Length; i++)
            {
                Console.WriteLine(split[i]);
            }
注：count不填则全部拆分

public enum StringSplitOptions
成员名称            说明
None                返回值包括含有空字符串的数组元素
RemoveEmptyEntries  返回值不包括含有空字符串的数组元素

如：
            string st = "语文|数学||英语|物理";
            string[] split = st.Split(new char[]{'|'},StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < split.Length; i++)
            {
                Console.WriteLine(split[i]);
            }
将StringSplitOptions枚举和Split()方法联系起来：
1.  public string[] Split ( char[] separator, StringSplitOptions options )：options指定StringSplitOptions枚举的RemoveEmptyEntries以省略返回的数组中的空数组元素，或指定StringSplitOptions枚举的None以包含返回的数组中的空数组元
2.  public string[] Split ( char[] separator, int count, StringSplitOptions options )
3.  public string[] Split ( string[] separator, StringSplitOptions options )
4.  public string[] Split ( string[] separator, int count, StringSplitOptions options )

9.Contains(判断是否存在)
public bool Contains(string text):如果字符串中出现text，则返回true，反之false，如果text为("")也返回true。
如：
string st="语文数学英语";
bool b=st.Contains("语文");
Console.WriteLine(b);//true

10.EndsWith,StartsWith(判断字符串的开始或结束)
public bool EndsWith ( string value )：判断对象包含字符串是否以value指定的字符串结束,是则为 true；否则为 false。
public bool EndsWith ( string value, StringComparison comparisonType ):第二个参数设置比较时区域、大小写和排序规则。
public bool StartsWith ( string value )：判断对象包含字符串是否以value指定的字符串开始,是则为 true；否则为 false。
public bool StartsWith ( string value, StringComparison comparisonType ) ：第二个参数设置比较时区域、大小写和排序规则。
如：
string st="语文数学英语abc";
bool b=st.EndsWith("英语ABC",StringComparison.CurrentCultureIgnoreCase);//第二个参数忽略大小比较。
Console.WriteLine(b);//true

11.Insert(字符串插入)
public string Insert ( int startIndex, string value )：在指定的字符串下标为startIndex前插入字符串value。返回插入后的值。
如：
string st="语文数学英语abc";
string newst=st.Insert(6,"物理");//注：在指定索引“前”插入。
Console.WriteLine(newst);//即：语文数学英语物理abc

自行实现比dotcore/dotnet更方便更高性能的对象二进制序列化

二进制序列化可以方便快捷的将对象进行持久化或者网络传输，并且体积小、性能高，应用面甚至还要高于json的序列化；开始之前，先来看看dotcore/dotne自带的二进制序列化：C#中对象序列化和反序列化一般是通过BinaryFormatter类来实现的二进制序列化、反序列化的。

BinaryFormatter序列化：

1 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer =　new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
2 
3 System.IO.MemoryStream memStream = new System.IO.MemoryStream();
4 
5 serializer.Serialize(memStream, request);

BinaryFormatter反序列化：

 1 　memStream.Position=0;
 2 
 3 　System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =
 4 
 5 　new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
 6 
 7 　object newobj = deserializer.Deserialize(memStream);
 8 
 9 　memStream.Close();
10 
11 　return newobj;

用着多了就发现BinaryFormatter有很多地方不妥，下面就来数数这个序列化的“三宗罪”：

1.类名上面要加上[Serializable]，不加不给序列化；正常的用法应该是序列化一个对象，不需的地方加上NonSerialized才合理吧；

2.序列化byte[]结果非常大，使用System.Text.Encoding.UTF8.GetString(bytes)查看下，发现里面有一大堆的元数据；对比看看google的protobuf，pb为什么在网络上应用的越来越多，这和他本身序列化完后体积小有着绝大部门的原因；

3.序列化对象需要完全一致，连类的命名空间都要相同，这点对于分面式开发的应用来说也是不可接受的；

既然BinaryFormatter不好用，那就只能动手自行实现一个解决上述问题的二进制序列化方案；首先去掉[Serializable]这个标签，接着主要是分析对象，并定义对象序列化后的数据结构；这里的想法是按长度加内容的方式来定义，举个例子：使用int作为长度，来保存一个int值,序列化完应该是：4,0,0,0,1,0,0,0这样的一组bytes，同理可以将int、short、long、float、double、datetime、enum、array、string、class、generic等按照这个格式进行序列化，这里主要使用的是BitConverter、反射等来实现序列化与反序列化；

序列化实现如下：

  1         public static byte[] Serialize(object param)
  2         {
  3             List datas = new List();
  4 
  5             var len = 0;
  6 
  7             byte[] data = null;
  8 
  9             if (param == null)
 10             {
 11                 len = 0;
 12             }
 13             else
 14             {
 15                 if (param is string)
 16                 {
 17                     data = Encoding.UTF8.GetBytes((string)param);
 18                 }
 19                 else if (param is byte)
 20                 {
 21                     data = new byte[] { (byte)param };
 22                 }
 23                 else if (param is bool)
 24                 {
 25                     data = BitConverter.GetBytes((bool)param);
 26                 }
 27                 else if (param is short)
 28                 {
 29                     data = BitConverter.GetBytes((short)param);
 30                 }
 31                 else if (param is int)
 32                 {
 33                     data = BitConverter.GetBytes((int)param);
 34                 }
 35                 else if (param is long)
 36                 {
 37                     data = BitConverter.GetBytes((long)param);
 38                 }
 39                 else if (param is float)
 40                 {
 41                     data = BitConverter.GetBytes((float)param);
 42                 }
 43                 else if (param is double)
 44                 {
 45                     data = BitConverter.GetBytes((double)param);
 46                 }
 47                 else if (param is DateTime)
 48                 {
 49                     var str = "wl" + ((DateTime)param).Ticks;
 50                     data = Encoding.UTF8.GetBytes(str);
 51                 }
 52                 else if (param is Enum)
 53                 {
 54                     var enumValType = Enum.GetUnderlyingType(param.GetType());
 55 
 56                     if (enumValType == typeof(byte))
 57                     {
 58                         data = new byte[] { (byte)param };
 59                     }
 60                     else if (enumValType == typeof(short))
 61                     {
 62                         data = BitConverter.GetBytes((Int16)param);
 63                     }
 64                     else if (enumValType == typeof(int))
 65                     {
 66                         data = BitConverter.GetBytes((Int32)param);
 67                     }
 68                     else
 69                     {
 70                         data = BitConverter.GetBytes((Int64)param);
 71                     }
 72                 }
 73                 else if (param is byte[])
 74                 {
 75                     data = (byte[])param;
 76                 }
 77                 else
 78                 {
 79                     var type = param.GetType();
 80 
 81 
 82                     if (type.IsGenericType || type.IsArray)
 83                     {
 84                         if (TypeHelper.DicTypeStrs.Contains(type.Name))
 85                             data = SerializeDic((System.Collections.IDictionary)param);
 86                         else if (TypeHelper.ListTypeStrs.Contains(type.Name) || type.IsArray)
 87                             data = SerializeList((System.Collections.IEnumerable)param);
 88                         else
 89                             data = SerializeClass(param, type);
 90                     }
 91                     else if (type.IsClass)
 92                     {
 93                         data = SerializeClass(param, type);
 94                     }
 95 
 96                 }
 97                 if (data != null)
 98                     len = data.Length;
 99             }
100             datas.AddRange(BitConverter.GetBytes(len));
101             if (len > 0)
102             {
103                 datas.AddRange(data);
104             }
105             return datas.Count == 0 ? null : datas.ToArray();
106         }

反序列化实现如下：

  1         public static object Deserialize(Type type, byte[] datas, ref int offset)
  2         {
  3             dynamic obj = null;
  4 
  5             var len = 0;
  6 
  7             byte[] data = null;
  8 
  9             len = BitConverter.ToInt32(datas, offset);
 10             offset += 4;
 11             if (len > 0)
 12             {
 13                 data = new byte[len];
 14                 Buffer.BlockCopy(datas, offset, data, 0, len);
 15                 offset += len;
 16 
 17                 if (type == typeof(string))
 18                 {
 19                     obj = Encoding.UTF8.GetString(data);
 20                 }
 21                 else if (type == typeof(byte))
 22                 {
 23                     obj = (data);
 24                 }
 25                 else if (type == typeof(bool))
 26                 {
 27                     obj = (BitConverter.ToBoolean(data, 0));
 28                 }
 29                 else if (type == typeof(short))
 30                 {
 31                     obj = (BitConverter.ToInt16(data, 0));
 32                 }
 33                 else if (type == typeof(int))
 34                 {
 35                     obj = (BitConverter.ToInt32(data, 0));
 36                 }
 37                 else if (type == typeof(long))
 38                 {
 39                     obj = (BitConverter.ToInt64(data, 0));
 40                 }
 41                 else if (type == typeof(float))
 42                 {
 43                     obj = (BitConverter.ToSingle(data, 0));
 44                 }
 45                 else if (type == typeof(double))
 46                 {
 47                     obj = (BitConverter.ToDouble(data, 0));
 48                 }
 49                 else if (type == typeof(decimal))
 50                 {
 51                     obj = (BitConverter.ToDouble(data, 0));
 52                 }
 53                 else if (type == typeof(DateTime))
 54                 {
 55                     var dstr = Encoding.UTF8.GetString(data);
 56                     var ticks = long.Parse(dstr.Substring(2));
 57                     obj = (new DateTime(ticks));
 58                 }
 59                 else if (type.BaseType == typeof(Enum))
 60                 {
 61                     var numType = Enum.GetUnderlyingType(type);
 62 
 63                     if (numType == typeof(byte))
 64                     {
 65                         obj = Enum.ToObject(type, data[0]);
 66                     }
 67                     else if (numType == typeof(short))
 68                     {
 69                         obj = Enum.ToObject(type, BitConverter.ToInt16(data, 0));
 70                     }
 71                     else if (numType == typeof(int))
 72                     {
 73                         obj = Enum.ToObject(type, BitConverter.ToInt32(data, 0));
 74                     }
 75                     else
 76                     {
 77                         obj = Enum.ToObject(type, BitConverter.ToInt64(data, 0));
 78                     }
 79                 }
 80                 else if (type == typeof(byte[]))
 81                 {
 82                     obj = (byte[])data;
 83                 }
 84                 else if (type.IsGenericType)
 85                 {
 86                     if (TypeHelper.ListTypeStrs.Contains(type.Name))
 87                     {
 88                         obj = DeserializeList(type, data);
 89                     }
 90                     else if (TypeHelper.DicTypeStrs.Contains(type.Name))
 91                     {
 92                         obj = DeserializeDic(type, data);
 93                     }
 94                     else
 95                     {
 96                         obj = DeserializeClass(type, data);
 97                     }
 98                 }
 99                 else if (type.IsClass)
100                 {
101                     obj = DeserializeClass(type, data);
102                 }
103                 else if (type.IsArray)
104                 {
105                     obj = DeserializeArray(type, data);
106                 }
107                 else
108                 {
109                     throw new RPCPamarsException("ParamsSerializeUtil.Deserialize 未定义的类型：" + type.ToString());
110                 }
111 
112             }
113             return obj;
114         }

其他详细的代码可以查看ParamsSerializeUtil.cs

功能基本实现了，下面对比一下10000次的实体序列化与反序列化测试结果：

实体代码：

 1             var groupInfo = new GroupInfo()
 2             {
 3                 GroupID = 1,
 4                 IsTemporary = false,
 5                 Name = "yswenli group",
 6                 Created = DateTimeHelper.Now,
 7                 Creator = new UserInfo()
 8                 {
 9 
10                     ID = 1,
11                     Birthday = DateTimeHelper.Now.AddYears(-100),
12                     UserName = "yswenli"
13                 },
14                 Users = new System.Collections.Generic.List()
15                 {
16                     new UserInfo()
17                     {
18 
19                         ID = 1,
20                         Birthday = DateTimeHelper.Now.AddYears(-100),
21                         UserName = "yswenli"
22                     }
23                 }
24             };

测试代码：

 1         public static byte[] SerializeBinary(object request)
 2         {
 3 
 4             System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer =
 5 
 6             new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
 7 
 8             using (System.IO.MemoryStream memStream = new System.IO.MemoryStream())
 9             {
10                 serializer.Serialize(memStream, request);
11 
12                 return memStream.ToArray();
13             }
14         }
15 
16 
17         public static object DeSerializeBinary(byte[] data)
18         {
19             using (System.IO.MemoryStream memStream = new System.IO.MemoryStream(data))
20             {
21                 System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =
22 
23                 new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
24 
25                 return deserializer.Deserialize(memStream);
26             }
27         }
28 
29         static void SerializeTest()
30         {
31             var groupInfo = new GroupInfo()
32             {
33                 GroupID = 1,
34                 IsTemporary = false,
35                 Name = "yswenli group",
36                 Created = DateTimeHelper.Now,
37                 Creator = new UserInfo()
38                 {
39 
40                     ID = 1,
41                     Birthday = DateTimeHelper.Now.AddYears(-100),
42                     UserName = "yswenli"
43                 },
44                 Users = new System.Collections.Generic.List()
45                 {
46                     new UserInfo()
47                     {
48 
49                         ID = 1,
50                         Birthday = DateTimeHelper.Now.AddYears(-100),
51                         UserName = "yswenli"
52                     }
53                 }
54             };
55 
56             var count = 100000;
57             var len1 = 0;
58             var len2 = 0;
59 
60             Stopwatch sw = new Stopwatch();
61             sw.Start();
62 
63             List list = new List();
64             for (int i = 0; i < count; i++)
65             {
66                 var bytes = SerializeBinary(groupInfo);
67                 len1 = bytes.Length;
68                 list.Add(bytes);
69             }
70             ConsoleHelper.WriteLine($"BinaryFormatter实体序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");
71 
72             sw.Restart();
73             for (int i = 0; i < count; i++)
74             {
75                 var obj = DeSerializeBinary(list[i]);
76             }
77             ConsoleHelper.WriteLine($"BinaryFormatter实体反序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");
78             ConsoleHelper.WriteLine($"BinaryFormatter序列化生成bytes大小：{len1 * count * 1.0 / 1024 / 1024} Mb");
79             list.Clear();
80             sw.Restart();
81 
82             for (int i = 0; i < count; i++)
83             {
84                 var bytes = RPC.Serialize.ParamsSerializeUtil.Serialize(groupInfo);
85                 len2 = bytes.Length;
86                 list.Add(bytes);
87             }
88             ConsoleHelper.WriteLine($"ParamsSerializeUtil实体序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");
89             sw.Restart();
90             for (int i = 0; i < count; i++)
91             {
92                 int os = 0;
93 
94                 var obj = RPC.Serialize.ParamsSerializeUtil.Deserialize(groupInfo.GetType(), list[i], ref os);
95             }
96             ConsoleHelper.WriteLine($"ParamsSerializeUtil实体反序列化平均：{count * 1000 / sw.ElapsedMilliseconds} 次/秒");
97             ConsoleHelper.WriteLine($"ParamsSerializeUtil序列化生成bytes大小：{len2 * count * 1.0 / 1024 / 1024} Mb");
98             sw.Stop();
99         }

运行结果：

自已动手做高性能消息队列

前言

本人觉得码农的技术提升应该是从how to do到why do，而项目或产品都是从why do到how to do，按题来，所以呢下面先从大的方面介绍一下消息队列。

消息队列是分布式高并发面目中必不可少的一部分，随着互联网、云计算、大数据的使用，消息队列的应用越来越多，消息队列在系统的可伸缩性、稳定性、提升吞吐量等方面有着显著的作用；它主要的作用一般如下：

1.通过异步处理提高系统性能

如上图，在不使用消息队列服务器的时候，用户的请求数据直接写入数据库，在高并发的情况下数据库压力剧增，使得响应速度变慢。但是在使用消息队列之后，用户的请求数据发送给消息队列之后立即返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。由于消息队列服务器处理速度快于数据库（消息队列也比数据库有更好的伸缩性），因此响应速度得到大幅改善。

通过以上分析我们可以得出消息队列具有很好的削峰作用的功能——即通过异步处理，将短时间高并发产生的事务消息存储在消息队列中，从而削平高峰期的并发事务。 举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。如下图所示：

线程安全使用（四） [.NET] 简单接入微信公众号开发：实现自动回复 [C#]C#中字符串的操作自行实现比dotcore/dotnet更方便更高性能的对象二进制序列化自已动手做高性能消息..._第11张图片

因为用户请求数据写入消息队列之后就立即返回给用户了，但是请求数据在后续的业务校验、写数据库等操作中可能失败。因此使用消息队列进行异步处理之后，需要适当修改业务流程进行配合，比如用户在提交订单之后，订单数据写入消息队列，不能立即返回用户订单提交成功，需要在消息队列的订单消费者进程真正处理完该订单之后，甚至出库后，再通过电子邮件或短信通知用户订单成功，以免交易纠纷。这就类似我们平时手机订火车票和电影票。

2.降低系统耦合性

我们知道模块分布式部署以后聚合方式通常有两种：1.分布式消息队列和2.分布式服务。先来简单说一下分布式服务：目前使用比较多的用来构建SOA（Service Oriented Architecture面向服务体系结构）的分布式服务框架是阿里巴巴开源的Dubbo.如果想深入了解Dubbo的可以看我写的关于Dubbo的这一篇文章：《高性能优秀的服务框架-dubbo介绍》：https://juejin.im/post/5acadeb1f265da2375072f9c 再来谈我们的分布式消息队列：我们知道如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，这样系统的可扩展性无疑更好一些。

我们最常见的事件驱动架构类似生产者消费者模式，在大型网站中通常用利用消息队列实现事件驱动结构。如下图所示：

消息队列使利用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息。 从上图可以看到消息发送者（生产者）和消息接受者（消费者）之间没有直接耦合，消息发送者将消息发送至分布式消息队列即结束对消息的处理，消息接受者从分布式消息队列获取该消息后进行后续处理，并不需要知道该消息从何而来。对新增业务，只要对该类消息感兴趣，即可订阅该消息，对原有系统和业务没有任何影响，从而实现网站业务的可扩展性设计。

消息接受者对消息进行过滤、处理、包装后，构造成一个新的消息类型，将消息继续发送出去，等待其他消息接受者订阅该消息。因此基于事件（消息对象）驱动的业务架构可以是一系列流程。

另外为了避免消息队列服务器宕机造成消息丢失，会将成功发送到消息队列的消息存储在消息生产者服务器上，等消息真正被消费者服务器处理后才删除消息。在消息队列服务器宕机后，生产者服务器会选择分布式消息队列服务器集群中的其他服务器发布消息。

前面说了这么多消息队列的重要性、使用场景、工作模式，有很多人就可能会说了，现有的ActiveMQ、RabbitMQ、Kafka、RocketMQ等多了去了，那在项目架构的时候选一个用上去就不行了，完全没有必要重复造轮子啊！本人认为对于重复造轮子的事情和其它任何事情都是一样的——任何事情没有绝对的好处或者坏处，比如是刚入门的码农、又或者很急的项目，完全可以选用现有一种通用的、成熟的产品，没必要去从零开始做；实际上没有任何一个优秀的产品全部使用三方的产品来组装完成的，任何一个好一点的项目发展到一定的时候都不约而同的进行底层开发。原因很简单：第一个任何通用型的产品总用功能覆盖不到的场景；第二个任何通用型的产品为了实现通用必将做了一些性能或架构的牺牲；现在道理都讲完了，开始动手了（都听你逼半天，能动手就尽量少逼逼！）。

概述

　　动手前先构思一下，本人需要一个简单的、可发布订阅的、高吞吐量的消息队列，并将之简单大的方面分成QServer、QClient；QServer主要有Exchange、Binding、MessageQueue构成；QClient和QServer共用一套相同的传输编解码器QCoder ，主要实现Publish、Subscribe、Unsubcribe、Closes等功能；先想这么多，开干！

Exchange

　　主要在QServer中提供发布、订阅、连接、队列信息等管理

  1 /****************************************************************************
  2 *Copyright (c) 2018 Microsoft All Rights Reserved.
  3 *CLR版本： 4.0.30319.42000
  4 *机器名称：WENLI-PC
  5 *公司名称：Microsoft
  6 *命名空间：SAEA.QueueSocket.Model
  7 *文件名： Exchange
  8 *版本号： V1.0.0.0
  9 *唯一标识：6a576aad-edcc-446d-b7e5-561a622549bf
 10 *当前的用户域：WENLI-PC
 11 *创建人： yswenli
 12 *电子邮箱：[email protected]
 13 *创建时间：2018/3/5 16:36:44
 14 *描述：
 15 *
 16 *=====================================================================
 17 *修改标记
 18 *修改时间：2018/3/5 16:36:44
 19 *修改人： yswenli
 20 *版本号： V1.0.0.0
 21 *描述：
 22 *
 23 *****************************************************************************/
 24 
 25 using SAEA.Commom;
 26 using SAEA.Sockets.Interface;
 27 using System;
 28 using System.Collections.Generic;
 29 using System.Linq;
 30 using System.Text;
 31 using System.Threading;
 32 using System.Threading.Tasks;
 33 
 34 namespace SAEA.QueueSocket.Model
 35 {
 36     class Exchange : ISyncBase
 37     {
 38         object _syncLocker = new object();
 39 
 40         public object SyncLocker
 41         {
 42             get
 43             {
 44                 return _syncLocker;
 45             }
 46         }
 47 
 48         long _pNum = 0;
 49 
 50         long _cNum = 0;
 51 
 52         long _inNum = 0;
 53 
 54         long _outNum = 0;
 55 
 56         private Binding _binding;
 57 
 58         private MessageQueue _messageQueue;
 59 
 60         public Exchange()
 61         {
 62             this._binding = new Binding();
 63 
 64             this._messageQueue = new MessageQueue();
 65         }
 66 
 67 
 68         public void AcceptPublish(string sessionID, QueueResult pInfo)
 69         {
 70             lock (_syncLocker)
 71             {
 72                 this._binding.Set(sessionID, pInfo.Name, pInfo.Topic);
 73 
 74                 this._messageQueue.Enqueue(pInfo.Topic, pInfo.Data);
 75 
 76                 _pNum = this._binding.GetPublisherCount();
 77 
 78                 Interlocked.Increment(ref _inNum);
 79             }
 80         }
 81 
 82         public void AcceptPublishForBatch(string sessionID, QueueResult[] datas)
 83         {
 84             if (datas != null)
 85             {
 86                 foreach (var data in datas)
 87                 {
 88                     if (data != null)
 89                     {
 90                         AcceptPublish(sessionID, data);
 91                     }
 92                 }
 93             }
 94         }
 95 
 96 
 97         public void GetSubscribeData(string sessionID, QueueResult sInfo, int maxSize = 500, int maxTime = 500, Action> callBack = null)
 98         {
 99             lock (_syncLocker)
100             {
101                 var result = this._binding.GetBingInfo(sInfo);
102 
103                 if (result == null)
104                 {
105                     this._binding.Set(sessionID, sInfo.Name, sInfo.Topic, false);
106 
107                     _cNum = this._binding.GetSubscriberCount();
108 
109                     Task.Factory.StartNew(() =>
110                     {
111                         while (this._binding.Exists(sInfo))
112                         {
113                             var list = this._messageQueue.DequeueForList(sInfo.Topic, maxSize, maxTime);
114                             if (list != null)
115                             {
116                                 list.ForEach(i => { Interlocked.Increment(ref _outNum); });
117                                 callBack?.Invoke(list);
118                                 list.Clear();
119                                 list = null;
120                             }
121                         }
122                     });
123                 }
124             }            
125         }
126 
127         public void Unsubscribe(QueueResult sInfo)
128         {
129             Interlocked.Decrement(ref _cNum);
130             this._binding.Del(sInfo.Name, sInfo.Topic);
131         }
132 
133         public void Clear(string sessionID)
134         {
135             lock (_syncLocker)
136             {
137                 var data = this._binding.GetBingInfo(sessionID);
138 
139                 if (data != null)
140                 {
141                     if (data.Flag)
142                     {
143                         Interlocked.Decrement(ref _pNum);
144                     }
145                     else
146                     {
147                         Interlocked.Decrement(ref _cNum);
148                     }
149                     this._binding.Remove(sessionID);
150                 }
151             }
152         }
153 
154         public Tuple GetConnectInfo()
155         {
156             return new Tuple(_pNum, _cNum, _inNum, _outNum);
157         }
158 
159         public List> GetQueueInfo()
160         {
161             List> result = new List>();
162             lock (_syncLocker)
163             {
164                 var list = this._messageQueue.ToList();
165                 if (list != null)
166                 {
167                     var tlts = list.Select(b => b.Topic).Distinct().ToList();
168 
169                     if (tlts != null)
170                     {
171                         foreach (var topic in tlts)
172                         {
173                             var count = this._messageQueue.GetCount(topic);
174                             var t = new Tuple(topic, count);
175                             result.Add(t);
176                         }
177                         tlts.Clear();
178                     }
179                     list.Clear();
180                 }
181             }
182             return result;
183         }
184 
185     }
186 }

　　思维发散：这里可以增加全局消息队列、指定连接消息队列等；将连接通过类型redis cluster模式进行一个均衡分布等

Binding

　　主要功能是将连接、主题进行映射管理

  1 /****************************************************************************
  2 *Copyright (c) 2018 Microsoft All Rights Reserved.
  3 *CLR版本： 4.0.30319.42000
  4 *机器名称：WENLI-PC
  5 *公司名称：Microsoft
  6 *命名空间：SAEA.QueueSocket.Model
  7 *文件名： Binding
  8 *版本号： V1.0.0.0
  9 *唯一标识：7472dabd-1b6a-4ffe-b19f-2d1cf7348766
 10 *当前的用户域：WENLI-PC
 11 *创建人： yswenli
 12 *电子邮箱：[email protected]
 13 *创建时间：2018/3/5 17:10:19
 14 *描述：
 15 *
 16 *=====================================================================
 17 *修改标记
 18 *修改时间：2018/3/5 17:10:19
 19 *修改人： yswenli
 20 *版本号： V1.0.0.0
 21 *描述：
 22 *
 23 *****************************************************************************/
 24 
 25 using SAEA.Commom;
 26 using SAEA.Sockets.Interface;
 27 using System;
 28 using System.Collections.Generic;
 29 using System.Linq;
 30 using System.Text;
 31 
 32 namespace SAEA.QueueSocket.Model
 33 {
 34     /// 
 35     /// 连接与主题的映射
 36     /// 
 37     class Binding : ISyncBase, IDisposable
 38     {
 39         List _list = new List();
 40 
 41         object _syncLocker = new object();
 42 
 43         public object SyncLocker
 44         {
 45             get
 46             {
 47                 return _syncLocker;
 48             }
 49         }
 50 
 51         bool _isDisposed = false;
 52 
 53         int _minutes = 10;
 54 
 55         public Binding(int minutes = 10)
 56         {
 57             _minutes = minutes;
 58 
 59             ThreadHelper.PulseAction(() =>
 60             {
 61                 lock (_syncLocker)
 62                 {
 63                     var list = _list.Where(b => b.Expired <= DateTimeHelper.Now).ToList();
 64                     if (list != null)
 65                     {
 66                         list.ForEach(item =>
 67                         {
 68                             _list.Remove(item);
 69                         });
 70                         list.Clear();
 71                         list = null;
 72                     }
 73                 }
 74             }, new TimeSpan(0, 0, 10), _isDisposed);
 75         }
 76 
 77 
 78         public void Set(string sessionID, string name, string topic, bool isPublisher = true)
 79         {
 80 
 81             lock (_syncLocker)
 82             {
 83                 var result = _list.FirstOrDefault(b => b.Name == name && b.Topic == topic);
 84                 if (result == null)
 85                 {
 86                     _list.Add(new BindInfo()
 87                     {
 88                         SessionID = sessionID,
 89                         Name = name,
 90                         Topic = topic,
 91                         Flag = isPublisher,
 92                         Expired = DateTimeHelper.Now.AddMinutes(_minutes)
 93                     });
 94                 }
 95                 else
 96                 {
 97                     result.Expired = DateTimeHelper.Now.AddMinutes(_minutes);
 98                 }
 99             }
100         }
101 
102         public void Del(string sessionID, string topic)
103         {
104             lock (_syncLocker)
105             {
106                 var result = _list.FirstOrDefault(b => b.Name == sessionID && b.Topic == topic);
107                 if (result != null)
108                 {
109                     _list.Remove(result);
110                 }
111             }
112         }
113 
114         public void Remove(string sessionID)
115         {
116             lock (_syncLocker)
117             {
118                 var result = _list.Where(b => b.SessionID == sessionID).ToList();
119                 if (result != null)
120                 {
121                     result.ForEach((item) =>
122                     {
123                         _list.Remove(item);
124                     });
125                     result.Clear();
126                 }
127             }
128         }
129 
130         public BindInfo GetBingInfo(QueueResult sInfo)
131         {
132             lock (_syncLocker)
133             {
134                 var bi = _list.FirstOrDefault(b => b.Name == sInfo.Name && b.Topic == sInfo.Topic);
135 
136                 if (bi != null)
137                 {
138                     if (bi.Expired <= DateTimeHelper.Now)
139                     {
140                         Remove(bi.SessionID);
141                     }
142                     else
143                     {
144                         return bi;
145                     }
146                 }
147                 return null;
148             }
149         }
150 
151         public BindInfo GetBingInfo(string sessionID)
152         {
153             lock (_syncLocker)
154             {
155                 return _list.FirstOrDefault(b => b.SessionID == sessionID);
156             }
157         }
158 
159         public bool Exists(QueueResult sInfo)
160         {
161             lock (_syncLocker)
162             {
163                 var data = _list.FirstOrDefault(b => b.Name == sInfo.Name && b.Topic == sInfo.Topic);
164 
165                 if (data != null)
166                 {
167                     if (data.Expired <= DateTimeHelper.Now)
168                     {
169                         Remove(data.SessionID);
170 
171                         return false;
172                     }
173 
174                     data.Expired = DateTimeHelper.Now.AddMinutes(_minutes);
175 
176                     return true;
177                 }
178             }
179             return false;
180         }
181 
182 
183         public IEnumerable GetPublisher()
184         {
185             lock (_syncLocker)
186             {
187                 return _list.Where(b => b.Flag);
188             }
189         }
190 
191         public int GetPublisherCount()
192         {
193             lock (_syncLocker)
194             {
195                 return _list.Where(b => b.Flag).Count();
196             }
197         }
198 
199         public IEnumerable GetSubscriber()
200         {
201             lock (_syncLocker)
202             {
203                 return _list.Where(b => !b.Flag);
204             }
205         }
206 
207         public int GetSubscriberCount()
208         {
209             lock (_syncLocker)
210             {
211                 return _list.Where(b => !b.Flag).Count();
212             }
213         }
214 
215 
216         public void Dispose()
217         {
218             _isDisposed = true;
219             lock (_syncLocker)
220             {
221                 _list.Clear();
222                 _list = null;
223             }
224         }
225     }
226 }

　　思维发散：实现多个QServer的主题与队列映射克隆、或者队列消息转发实现容灾集群或大容量集群等

MessageQueue

　　将主题与队列形成一个映射，并对主题映射进行管理

  1 /****************************************************************************
  2 *Copyright (c) 2018 Microsoft All Rights Reserved.
  3 *CLR版本： 4.0.30319.42000
  4 *机器名称：WENLI-PC
  5 *公司名称：Microsoft
  6 *命名空间：SAEA.QueueSocket.Model
  7 *文件名： QueueCollection
  8 *版本号： V1.0.0.0
  9 *唯一标识：89a65c12-c4b3-486b-a933-ad41c3db6621
 10 *当前的用户域：WENLI-PC
 11 *创建人： yswenli
 12 *电子邮箱：[email protected]
 13 *创建时间：2018/3/6 10:31:11
 14 *描述：
 15 *
 16 *=====================================================================
 17 *修改标记
 18 *修改时间：2018/3/6 10:31:11
 19 *修改人： yswenli
 20 *版本号： V1.0.0.0
 21 *描述：
 22 *
 23 *****************************************************************************/
 24 
 25 using SAEA.Commom;
 26 using SAEA.Sockets.Interface;
 27 using System;
 28 using System.Collections.Concurrent;
 29 using System.Collections.Generic;
 30 using System.Linq;
 31 using System.Threading.Tasks;
 32 
 33 namespace SAEA.QueueSocket.Model
 34 {
 35     public class MessageQueue : ISyncBase, IDisposable
 36     {
 37         bool _isDisposed = false;
 38 
 39         ConcurrentDictionary _list;
 40 
 41         object _syncLocker = new object();
 42 
 43         public object SyncLocker
 44         {
 45             get
 46             {
 47                 return _syncLocker;
 48             }
 49         }
 50 
 51         public MessageQueue()
 52         {
 53             _list = new ConcurrentDictionary();
 54 
 55             ThreadHelper.Run(() =>
 56             {
 57                 while (!_isDisposed)
 58                 {
 59                     var list = _list.Values.Where(b => b.Expired <= DateTimeHelper.Now);
 60                     if (list != null)
 61                     {
 62                         foreach (var item in list)
 63                         {
 64                             if (item.Length == 0)
 65                             {
 66                                 _list.TryRemove(item.Topic, out QueueBase q);
 67                             }
 68                         }
 69                     }
 70                     ThreadHelper.Sleep(10000);
 71                 }
 72             }, true, System.Threading.ThreadPriority.Highest);
 73         }
 74 
 75 
 76         public void Enqueue(string topic, string data)
 77         {
 78             var queue = _list.Values.FirstOrDefault(b => b.Topic.Equals(topic));
 79             lock (_syncLocker)
 80             {
 81                 if (queue == null)
 82                 {
 83                     queue = new QueueBase(topic);
 84                     _list.TryAdd(topic, queue);
 85                 }                
 86             }
 87             queue.Enqueue(data);
 88         }
 89 
 90 
 91         public string Dequeue(string topic)
 92         {
 93             var queue = _list.Values.FirstOrDefault(b => b.Topic.Equals(topic));
 94             if (queue != null)
 95             {
 96                 return queue.Dequeue();
 97             }
 98             return null;
 99         }
100 
101         /// 
102         /// 批量读取数据
103         /// 
104         /// 
105         /// 
106         /// 
107         /// 
108         public List DequeueForList(string topic, int maxSize = 500, int maxTime = 500)
109         {
110             List result = new List();
111             bool running = true;
112             var m = 0;
113             var task = Task.Factory.StartNew(() =>
114             {
115                 while (running)
116                 {
117                     var data = Dequeue(topic);
118                     if (data != null)
119                     {
120                         result.Add(data);
121                         m++;
122                         if (m == maxSize)
123                         {
124                             running = false;
125                         }
126                     }
127                     else
128                     {
129                         ThreadHelper.Sleep(1);
130                     }
131                 }
132             });
133             Task.WaitAll(new Task[] { task }, maxTime);
134             running = false;
135             return result;
136         }
137 
138         public string BlockDequeue(string topic)
139         {
140             var queue = _list.Values.FirstOrDefault(b => b.Topic == topic);
141             if (queue != null)
142             {
143                 return queue.BlockDequeue();
144             }
145             return null;
146         }
147 
148         public List ToList()
149         {
150             lock (_syncLocker)
151             {
152                 return _list.Values.ToList();
153             }
154         }
155 
156         public long GetCount(string topic)
157         {
158             var queue = _list.Values.FirstOrDefault(b => b.Topic == topic);
159             if (queue != null)
160                 return queue.Length;
161             return 0;
162         }
163 
164         public void Dispose()
165         {
166             _isDisposed = true;
167             _list.Clear();
168                 _list = null;
169         }
170     }
171 }

　　思维发散：增加硬盘持久化以实现down机容灾、增加ack确认再移除以实现高可靠性等

QCoder

　　在QServer和QClient之间进行传输编解码，这个编解码的速度直接影响消息队列的传输性能；本人使用了2种方案：1.使用类似redis传输方案，使用回车作为分隔符方式，这种方案结果要么一个字节一个字节检查分隔符，这种for操作还是C、C++屌，C#做这个真心不行；要么先将字节数组通过Encoding转换成String再来for，虽说能提升几倍性能，但是遇到不完整的字节数组时，本人没有找一个好的方法。2.使用自定义类型+长度+内容这种格式

  1 /****************************************************************************
  2 *Copyright (c) 2018 Microsoft All Rights Reserved.
  3 *CLR版本： 4.0.30319.42000
  4 *机器名称：WENLI-PC
  5 *公司名称：Microsoft
  6 *命名空间：SAEA.QueueSocket.Net
  7 *文件名： QCoder
  8 *版本号： V1.0.0.0
  9 *唯一标识：88f5a779-8294-47bc-897b-8357a09f2fdb
 10 *当前的用户域：WENLI-PC
 11 *创建人： yswenli
 12 *电子邮箱：[email protected]
 13 *创建时间：2018/3/5 18:01:56
 14 *描述：
 15 *
 16 *=====================================================================
 17 *修改标记
 18 *修改时间：2018/3/5 18:01:56
 19 *修改人： yswenli
 20 *版本号： V1.0.0.0
 21 *描述：
 22 *
 23 *****************************************************************************/
 24 
 25 using SAEA.Commom;
 26 using SAEA.QueueSocket.Model;
 27 using SAEA.QueueSocket.Type;
 28 using SAEA.Sockets.Interface;
 29 using System;
 30 using System.Collections.Generic;
 31 using System.Text;
 32 
 33 namespace SAEA.QueueSocket.Net
 34 {
 35     public sealed class QCoder : ICoder
 36     {
 37         static readonly int MIN = 1 + 4 + 4 + 0 + 4 + 0 + 0;
 38 
 39         private List _buffer = new List();
 40 
 41         private object _locker = new object();
 42 
 43         public void Pack(byte[] data, Action onHeart, Action onUnPackage, Action onFile)
 44         {
 45 
 46         }
 47 
 48         /// 
 49         /// 队列编解码器
 50         /// 
 51         public QueueCoder QueueCoder { get; set; } = new QueueCoder();
 52 
 53         /// 
 54         /// 包解析
 55         /// 
 56         /// 
 57         /// 
 58         public void GetQueueResult(byte[] data, Action OnQueueResult)
 59         {
 60             lock (_locker)
 61             {
 62                 try
 63                 {
 64                     _buffer.AddRange(data);
 65 
 66                     if (_buffer.Count > (1 + 4 + 4 + 0 + 4 + 0 + 0))
 67                     {
 68                         var buffer = _buffer.ToArray();
 69 
 70                         QCoder.Decode(buffer, (list, offset) =>
 71                         {
 72                             if (list != null)
 73                             {
 74                                 foreach (var item in list)
 75                                 {
 76                                     OnQueueResult?.Invoke(new QueueResult()
 77                                     {
 78                                         Type = (QueueSocketMsgType)item.Type,
 79                                         Name = item.Name,
 80                                         Topic = item.Topic,
 81                                         Data = item.Data
 82                                     });
 83                                 }
 84                                 _buffer.RemoveRange(0, offset);
 85                             }
 86                         });
 87                     }
 88                 }
 89                 catch (Exception ex)
 90                 {
 91                     ConsoleHelper.WriteLine("QCoder.GetQueueResult error:" + ex.Message + ex.Source);
 92                     _buffer.Clear();
 93                 }
 94             }
 95         }
 96 
 97 
 98 
 99         /// 
100         /// socket 传输字节编码
101         /// 格式为：1+4+4+x+4+x+4
102         /// 
103         /// 
104         /// 
105         public static byte[] Encode(QueueSocketMsg queueSocketMsg)
106         {
107             List list = new List();
108 
109             var total = 4 + 4 + 4;
110 
111             var nlen = 0;
112 
113             var tlen = 0;
114 
115             byte[] n = null;
116             byte[] tp = null;
117             byte[] d = null;
118 
119             if (!string.IsNullOrEmpty(queueSocketMsg.Name))
120             {
121                 n = Encoding.UTF8.GetBytes(queueSocketMsg.Name);
122                 nlen = n.Length;
123                 total += nlen;
124             }
125             if (!string.IsNullOrEmpty(queueSocketMsg.Topic))
126             {
127                 tp = Encoding.UTF8.GetBytes(queueSocketMsg.Topic);
128                 tlen = tp.Length;
129                 total += tlen;
130             }
131             if (!string.IsNullOrEmpty(queueSocketMsg.Data))
132             {
133                 d = Encoding.UTF8.GetBytes(queueSocketMsg.Data);
134                 total += d.Length;
135             }
136 
137             list.Add(queueSocketMsg.Type);
138             list.AddRange(BitConverter.GetBytes(total));
139             list.AddRange(BitConverter.GetBytes(nlen));
140             if (nlen > 0)
141                 list.AddRange(n);
142             list.AddRange(BitConverter.GetBytes(tlen));
143             if (tlen > 0)
144                 list.AddRange(tp);
145             if (d != null)
146                 list.AddRange(d);
147             var arr = list.ToArray();
148             list.Clear();
149             return arr;
150         }
151 
152         /// 
153         /// socket 传输字节解码
154         /// 
155         /// 
156         /// 
157         public static bool Decode(byte[] data, Action onDecode)
158         {
159             int offset = 0;
160 
161             try
162             {
163                 if (data != null && data.Length > offset + MIN)
164                 {
165                     var list = new List();
166 
167                     while (data.Length > offset + MIN)
168                     {
169                         var total = BitConverter.ToInt32(data, offset + 1);
170 
171                         if (data.Length >= offset + total + 1)
172                         {
173                             offset += 5;
174 
175                             var qm = new QueueSocketMsg((QueueSocketMsgType)data[0]);
176                             qm.Total = total;
177 
178                             qm.NLen = BitConverter.ToInt32(data, offset);
179                             offset += 4;
180 
181 
182                             if (qm.NLen > 0)
183                             {
184                                 var narr = new byte[qm.NLen];
185                                 Buffer.BlockCopy(data, offset, narr, 0, narr.Length);
186                                 qm.Name = Encoding.UTF8.GetString(narr);
187                             }
188                             offset += qm.NLen;
189 
190                             qm.TLen = BitConverter.ToInt32(data, offset);
191 
192                             offset += 4;
193 
194                             if (qm.TLen > 0)
195                             {
196                                 var tarr = new byte[qm.TLen];
197                                 Buffer.BlockCopy(data, offset, tarr, 0, tarr.Length);
198                                 qm.Topic = Encoding.UTF8.GetString(tarr);
199                             }
200                             offset += qm.TLen;
201 
202                             var dlen = qm.Total - 4 - 4 - qm.NLen - 4 - qm.TLen;
203 
204                             if (dlen > 0)
205                             {
206                                 var darr = new byte[dlen];
207                                 Buffer.BlockCopy(data, offset, darr, 0, dlen);
208                                 qm.Data = Encoding.UTF8.GetString(darr);
209                                 offset += dlen;
210                             }
211                             list.Add(qm);
212                         }
213                         else
214                         {
215                             break;
216                         }
217                     }
218                     if (list.Count > 0)
219                     {
220                         onDecode?.Invoke(list.ToArray(), offset);
221                         return true;
222                     }
223                 }
224             }
225             catch (Exception ex)
226             {
227                 ConsoleHelper.WriteLine($"QCoder.Decode error:{ex.Message} stack:{ex.StackTrace} data:{data.Length} offset:{offset}");
228             }
229             onDecode?.Invoke(null, 0);
230             return false;
231         }
232 
233 
234         /// 
235         /// dispose
236         /// 
237         public void Dispose()
238         {
239             _buffer.Clear();
240             _buffer = null;
241         }
242 
243 
244 
245     }
246 }

测试

　　简单的How to do和Why do已经完成了，是时候定义个Producer、Consumer来测试一把了

  1 using SAEA.QueueSocket;
  2 using SAEA.Commom;
  3 using SAEA.QueueSocket.Model;
  4 using System;
  5 using System.Collections.Generic;
  6 using System.Diagnostics;
  7 using System.Text;
  8 using System.Threading;
  9 using System.Threading.Tasks;
 10 
 11 namespace SAEA.QueueSocketTest
 12 {
 13     class Program
 14     {
 15         static void Main(string[] args)
 16         {
 17             do
 18             {
 19                 ConsoleHelper.WriteLine("输入s启动队列服务器,输入p启动生产者，输入c启动消费者");
 20 
 21                 var inputStr = ConsoleHelper.ReadLine();
 22 
 23                 if (!string.IsNullOrEmpty(inputStr))
 24                 {
 25                     var topic = "测试频道";
 26 
 27                     switch (inputStr.ToLower())
 28                     {
 29                         case "s":
 30                             ConsoleHelper.Title = "SAEA.QueueServer";
 31                             ServerInit();
 32                             break;
 33                         case "p":
 34                             ConsoleHelper.Title = "SAEA.QueueProducer";
 35                             ConsoleHelper.WriteLine("输入ip:port连接到队列服务器");
 36                             inputStr = ConsoleHelper.ReadLine();
 37                             ProducerInit(inputStr, topic);
 38                             break;
 39                         case "c":
 40                             ConsoleHelper.Title = "SAEA.QueueConsumer";
 41                             ConsoleHelper.WriteLine("输入ip:port连接到队列服务器");
 42                             inputStr = ConsoleHelper.ReadLine();
 43                             ConsumerInit(inputStr, topic);
 44                             break;
 45                         default:
 46                             ServerInit();
 47                             inputStr = "127.0.0.1:39654";
 48                             ProducerInit(inputStr, topic);
 49                             ConsumerInit(inputStr, topic);
 50                             break;
 51                     }
 52                     ConsoleHelper.WriteLine("回车退出！");
 53                     ConsoleHelper.ReadLine();
 54                     return;
 55                 }
 56             }
 57             while (true);
 58         }
 59 
 60 
 61 
 62         static QServer _server;
 63         static void ServerInit()
 64         {
 65             _server = new QServer();
 66             _server.OnDisconnected += Server_OnDisconnected;
 67             _server.CalcInfo((ci, qi) =>
 68             {
 69                 var result = string.Format("生产者：{0} 消费者：{1} 收到消息:{2} 推送消息:{3}{4}", ci.Item1, ci.Item2, ci.Item3, ci.Item4, Environment.NewLine);
 70 
 71                 qi.ForEach((item) =>
 72                 {
 73                     result += string.Format("队列名称：{0} 堆积消息数：{1} {2}", item.Item1, item.Item2, Environment.NewLine);
 74                 });
 75                 ConsoleHelper.WriteLine(result);
 76             });
 77             _server.Start();
 78         }
 79 
 80         private static void Server_OnDisconnected(string ID, Exception ex)
 81         {
 82             _server.Clear(ID);
 83             if (ex != null)
 84             {
 85                 ConsoleHelper.WriteLine("{0} 已从服务器断开，err:{1}", ID, ex.ToString());
 86             }
 87         }
 88 
 89         static void ProducerInit(string ipPort, string topic)
 90         {
 91             int pNum = 0;
 92 
 93             //string msg = "主要原因是由于在高并发环境下，由于来不及同步处理，请求往往会发生堵塞，比如说，大量的insert，update之类的请求同时到达MySQL，直接导致无数的行锁表锁，甚至最后请求会堆积过多，从而触发too many connections错误。通过使用消息队列，我们可以异步处理请求，从而缓解系统的压力。";
 94             string msg = "123";
 95             if (string.IsNullOrEmpty(ipPort)) ipPort = "127.0.0.1:39654";
 96 
 97             QClient producer = new QClient("productor" + Guid.NewGuid().ToString("N"), ipPort);
 98 
 99             producer.OnError += Producer_OnError;
100 
101             producer.OnDisconnected += Client_OnDisconnected;
102 
103             producer.ConnectAsync((s) =>
104             {
105                 Task.Factory.StartNew(() =>
106                 {
107                     var old = 0;
108                     var speed = 0;
109                     while (producer.Connected)
110                     {
111                         speed = pNum - old;
112                         old = pNum;
113                         ConsoleHelper.WriteLine("生产者已成功发送：{0} 速度：{1}/s", pNum, speed);
114                         Thread.Sleep(1000);
115                     }
116                 });
117 
118                 var list = new List>();
119                 
120 
121                 while (producer.Connected)
122                 {                   
123 
124                     producer.Publish(topic, msg);
125 
126                     Interlocked.Increment(ref pNum);
127                 }
128             });
129 
130 
131         }
132 
133         private static void Producer_OnError(string ID, Exception ex)
134         {
135             ConsoleHelper.WriteLine("id:" + ID + ",error:" + ex.Message);
136         }
137 
138         static void ConsumerInit(string ipPort, string topic)
139         {
140             if (string.IsNullOrEmpty(ipPort)) ipPort = "127.0.0.1:39654";
141             QClient consumer = new QClient("subscriber-" + Guid.NewGuid().ToString("N"), ipPort);
142             consumer.OnMessage += Subscriber_OnMessage;
143             consumer.OnDisconnected += Client_OnDisconnected;
144             consumer.ConnectAsync((s) =>
145             {
146                 Task.Factory.StartNew(() =>
147                 {
148                     var old = 0;
149                     var speed = 0;
150                     while (consumer.Connected)
151                     {
152                         speed = _outNum - old;
153                         old = _outNum;
154                         ConsoleHelper.WriteLine("消费者已成功接收：{0} 速度：{1}/s", _outNum, speed);
155                         Thread.Sleep(1000);
156                     }
157                 });
158 
159                 consumer.Subscribe(topic);
160             });
161 
162         }
163 
164         private static void Client_OnDisconnected(string ID, Exception ex)
165         {
166             ConsoleHelper.WriteLine("当前连接已关闭");
167         }
168 
169         static int _outNum = 0;
170 
171         private static void Subscriber_OnMessage(QueueResult obj)
172         {
173             if (obj != null)
174                 _outNum += 1;
175         }
176     }
177 }

　　单线程的、单生产者、单消费者、单队列服务器的测试结果如下图：

　　到此一个自行实现的简单的消息队列完成了，虽说它离实际产品还很遥远，但是本人还是觉的技术的提升离不开钻研，路漫漫其修远兮，吾将上下而求索！

转载请标明本文来源：http://www.cnblogs.com/yswenli/p//9029587.html
更多内容欢迎star作者的github：https://github.com/yswenli/SAEA
如果发现本文有什么问题和任何建议，也随时欢迎交流~

感谢您的阅读，如果您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是yswenli 。

自行实现高性能MVC WebAPI

　　wcf虽然功能多、扩展性强但是也面临配置忒多，而且restful的功能相当怪异，并且目前没法移植。asp.net core虽然支持webapi，但是功能也相对繁多、配置复杂。就没有一个能让码农们安安心心的写webapi，无需考虑性能、配置、甚至根据问题场景自行设计、改造等问题的方案么？

　　当然不是，特别是在dnc2.0已经相当强大的此时，完全可以自行设计一套简洁、高效的webapi框架！说到自行写一套框架，很多码农们就可能会想到开发工作量难以想像，事实真的如此么？java因为开源众多，很多对mvc稍有了解的都可以拿这个拿那个拼出一个自已的mvc框架；而面对日益强大的dnc，本人觉得C#根本无需东拼西凑这么麻烦，完全可以根据自已的需求简单快速的写出一个来，不服就开干！

　　设计的编码思路就是仿asp.net mvc，原因就是asp.net mvc成功发展了这么多年，有着大量的C#码农习惯了这套优良的编码方式；至于spring mvc、spring boot那些，站在使用者的角度来说，光配置和注解都能敲死人，如要要说简洁快速，asp.net mvc比他强多了，更别提ruby on rails。不扯远了，下面就按C#经典来。那么需要考虑的问题有tcp、http、request、response、server、controller、actionresult、routetable等，下面就一一来解决这个问题。

　　一、Tcp：这个是实现传输通信的底层，当然采用IOCP来提高吞吐量和性能，本人之前在做Redis Client等的时候就使用这个IOCP Socket的框架，此时正好也可以用上

 1 /****************************************************************************
 2 *Copyright (c) 2018 Microsoft All Rights Reserved.
 3 *CLR版本： 4.0.30319.42000
 4 *机器名称：WENLI-PC
 5 *公司名称：Microsoft
 6 *命名空间：SAEA.WebAPI.Http.Net
 7 *文件名： ServerSocket
 8 *版本号： V1.0.0.0
 9 *唯一标识：ab912b9a-c7ed-44d9-8e48-eef0b6ff86a2
10 *当前的用户域：WENLI-PC
11 *创建人： yswenli
12 *电子邮箱：[email protected]
13 *创建时间：2018/4/8 17:11:15
14 *描述：
15 *
16 *=====================================================================
17 *修改标记
18 *修改时间：2018/4/8 17:11:15
19 *修改人： yswenli
20 *版本号： V1.0.0.0
21 *描述：
22 *
23 *****************************************************************************/
24 using SAEA.Sockets.Core;
25 using SAEA.Sockets.Interface;
26 using System;
27 using System.Collections.Generic;
28 using System.Net;
29 using System.Text;
30 
31 namespace SAEA.WebAPI.Http.Net
32 {
33     class ServerSocket : BaseServerSocket
34     {
35         public event Action OnRequested;
36 
37         public ServerSocket(int bufferSize = 1024 * 100, int count = 10000) : base(new HContext(), bufferSize, true, count)
38         {
39 
40         }
41 
42         protected override void OnReceiveBytes(IUserToken userToken, byte[] data)
43         {
44             HCoder coder = (HCoder)userToken.Coder;
45 
46             coder.GetRequest(data, (result) =>
47             {
48                 OnRequested?.Invoke(userToken, result);
49             });
50         }
51 
52         public void Reply(IUserToken userToken, byte[] data)
53         {
54             base.Send(userToken, data);
55             base.Disconnected(userToken);
56         }
57     }
58 }

　　二、Http：这个是个应用协议，本人了解下来至少有3个版本，完全熟悉的话估计没个半年都搞不定；但是只需要关键，比如说http1.1的工作模式、传输格式、常见异常code、常见mime类型、js跨域支持等，这些基本能覆盖绝大部分日常场景，至于更多的那些细枝末节的理它作甚，本人的做法就是用Chrome的开发人员工具来查看相关network详情，这样的话就可以清楚http这个协议的具体编码解码了。

 1         public void GetRequest(byte[] data, Action onUnpackage)
 2         {
 3             lock (_locker)
 4             {
 5                 var str = Encoding.UTF8.GetString(data);
 6 
 7                 var index = str.IndexOf(ENDSTR);
 8 
 9                 if (index > -1)
10                 {
11                     var s = str.Substring(0, index);
12 
13                     _result.Append(s);
14 
15                     onUnpackage.Invoke(_result.ToString());
16 
17                     _result.Clear();
18 
19                     if (str.Length > index + 4)
20                     {
21                         _result.Append(str.Substring(index + 4));
22                     }
23                 }
24                 else
25                 {
26                     _result.Append(str);
27                 }
28             }
29         }

　　经过分析后http的内容格式其实就是字符回车分隔，再加上一些约定生成的分隔符bound完成的。

 1         public HttpRequest(Stream stream)
 2         {
 3             this._dataStream = stream;
 4             var data = GetRequestData(_dataStream);
 5             var rows = Regex.Split(data, Environment.NewLine);
 6 
 7             //Request URL & Method & Version
 8             var first = Regex.Split(rows[0], @"(\s+)")
 9                 .Where(e => e.Trim() != string.Empty)
10                 .ToArray();
11             if (first.Length > 0) this.Method = first[0];
12             if (first.Length > 1)
13             {
14                 this.Query = first[1];
15 
16                 if (this.Query.Contains("?"))
17                 {
18                     var qarr = this.Query.Split("?");
19                     this.URL = qarr[0];
20                     this.Params = GetRequestParameters(qarr[1]);
21                 }
22                 else
23                 {
24                     this.URL = this.Query;
25                 }
26 
27                 var uarr = this.URL.Split("/");
28 
29                 if (long.TryParse(uarr[uarr.Length - 1], out long id))
30                 {
31                     this.URL = this.URL.Substring(0, this.URL.LastIndexOf("/"));
32                     this.Params.Set("id", id.ToString());
33                 }
34             }
35             if (first.Length > 2) this.Protocols = first[2];
36 
37             //Request Headers
38             this.Headers = GetRequestHeaders(rows);
39 
40             //Request "GET"
41             if (this.Method == "GET")
42             {
43                 this.Body = GetRequestBody(rows);
44             }
45 
46             //Request "POST"
47             if (this.Method == "POST")
48             {
49                 this.Body = GetRequestBody(rows);
50                 var contentType = GetHeader(RequestHeaderType.ContentType);
51                 var isUrlencoded = contentType == @"application/x-www-form-urlencoded";
52                 if (isUrlencoded) this.Params = GetRequestParameters(this.Body);
53             }
54         }

　　看到上面，有人肯定会说你这个传文件咋办？一个呢本人这个是针对webapi；另外一个，如真有这个场景，可以用Chrome的开发人员工具来查看相关network详情，也可以使用httpanalyzerstd、httpwatch等众多工具分析下，其实也就是使用了一些约定的分隔符bound完成，每个浏览器还不一样，有兴趣的完全可以自行扩展一个。

　　三、Reponse这个是webapi服务端相当重要的一个组件，本人也是尽可能方便并且按尽量按asp.net mvc的命名来实现，另外这里加入支持js跨域所需大部分场景heads，如果还有特殊的heads，完全可以自已添加。

View Code

　　四、HttpServer：这个就是承载webapi的容器；有人说不是有IIS和Apache么？本人想说的是：有self-host方便么？有无需安装，无需配置、随便高性能开跑好么？asp.net core里面都有了这个，没这个就没有逼格....(此处省略一万字)，前面还研究tcp、http这个当然不能少了

 1 /****************************************************************************
 2 *Copyright (c) 2018 Microsoft All Rights Reserved.
 3 *CLR版本： 4.0.30319.42000
 4 *机器名称：WENLI-PC
 5 *公司名称：Microsoft
 6 *命名空间：SAEA.WebAPI.Http
 7 *文件名： HttpServer
 8 *版本号： V1.0.0.0
 9 *唯一标识：914acb72-d4c4-4fa1-8e80-ce2f83bd06f0
10 *当前的用户域：WENLI-PC
11 *创建人： yswenli
12 *电子邮箱：[email protected]
13 *创建时间：2018/4/10 13:51:50
14 *描述：
15 *
16 *=====================================================================
17 *修改标记
18 *修改时间：2018/4/10 13:51:50
19 *修改人： yswenli
20 *版本号： V1.0.0.0
21 *描述：
22 *
23 *****************************************************************************/
24 using SAEA.Sockets.Interface;
25 using SAEA.WebAPI.Common;
26 using SAEA.WebAPI.Http.Net;
27 using System;
28 using System.Collections.Generic;
29 using System.IO;
30 using System.Text;
31 
32 namespace SAEA.WebAPI.Http
33 {
34     class HttpServer
35     {
36         ServerSocket _serverSocket;
37 
38         public HttpServer()
39         {
40             _serverSocket = new ServerSocket();
41             _serverSocket.OnRequested += _serverSocket_OnRequested;
42         }
43 
44         public void Start(int port = 39654)
45         {
46             _serverSocket.Start(port);
47         }
48 
49 
50         private void _serverSocket_OnRequested(IUserToken userToken, string htmlStr)
51         {
52             var httpContext = HttpContext.CreateInstance(this, userToken, htmlStr);
53 
54             var response = httpContext.Response;
55 
56             response.End();
57         }
58 
59         internal void Replay(IUserToken userToken, byte[] data)
60         {
61             _serverSocket.Reply(userToken, data);
62         }
63 
64         internal void Close(IUserToken userToken)
65         {
66             _serverSocket.Disconnected(userToken);
67         }
68 
69 
70     }
71 }

　　五、Controller：为了实现类似于mvc的效果Controller这个大名鼎鼎的当然不能少了，其在C#中使用非常少量的代码即可实现

 1 /****************************************************************************
 2 *Copyright (c) 2018 Microsoft All Rights Reserved.
 3 *CLR版本： 4.0.30319.42000
 4 *机器名称：WENLI-PC
 5 *公司名称：Microsoft
 6 *命名空间：SAEA.WebAPI.Mvc
 7 *文件名： Controller
 8 *版本号： V1.0.0.0
 9 *唯一标识：a303db7d-f83c-4c49-9804-032ec2236232
10 *当前的用户域：WENLI-PC
11 *创建人： yswenli
12 *电子邮箱：[email protected]
13 *创建时间：2018/4/10 13:58:08
14 *描述：
15 *
16 *=====================================================================
17 *修改标记
18 *修改时间：2018/4/10 13:58:08
19 *修改人： yswenli
20 *版本号： V1.0.0.0
21 *描述：
22 *
23 *****************************************************************************/
24 
25 using SAEA.WebAPI.Http;
26 
27 namespace SAEA.WebAPI.Mvc
28 {
29     /// 
30     /// WebApi控制器
31     /// 
32     public abstract class Controller
33     {
34         public HttpContext HttpContext { get; set; }
35 
36         /// 
37         /// 返回Json
38         /// 
39         /// 
40         /// 
41         protected JsonResult Json(object data)
42         {
43             return new JsonResult(data);
44         }
45         /// 
46         /// 自定义内容
47         /// 
48         /// 
49         /// 
50         protected ContentResult Content(string data)
51         {
52             return new ContentResult(data);
53         }
54 
55 
56         /// 
57         /// 小文件
58         /// 
59         /// 
60         /// 
61         protected FileResult File(string filePath)
62         {
63             return new FileResult(filePath);
64         }
65 
66         /// 
67         /// 空结果
68         /// 
69         /// 
70         protected EmptyResult Empty()
71         {
72             return new EmptyResult();
73         }
74     }
75 }

　　六、ActionResult：是mvc里面针对reponse结果进行了一个http格式的封装，本人主要实现了ContentResult、JsonResult、FileResult三个，至于其他的在WebAPI里基本上用不到。

 1 /****************************************************************************
 2 *Copyright (c) 2018 Microsoft All Rights Reserved.
 3 *CLR版本： 4.0.30319.42000
 4 *机器名称：WENLI-PC
 5 *公司名称：Microsoft
 6 *命名空间：SAEA.WebAPI.Mvc
 7 *文件名： JsonResult
 8 *版本号： V1.0.0.0
 9 *唯一标识：340c3ef0-2e98-4f25-998f-2bb369fa2794
10 *当前的用户域：WENLI-PC
11 *创建人： yswenli
12 *电子邮箱：[email protected]
13 *创建时间：2018/4/10 16:48:06
14 *描述：
15 *
16 *=====================================================================
17 *修改标记
18 *修改时间：2018/4/10 16:48:06
19 *修改人： yswenli
20 *版本号： V1.0.0.0
21 *描述：
22 *
23 *****************************************************************************/
24 using SAEA.WebAPI.Common;
25 using System;
26 using System.Collections.Generic;
27 using System.Net;
28 using System.Text;
29 
30 namespace SAEA.WebAPI.Mvc
31 {
32     public class JsonResult : ActionResult
33     {
34         public JsonResult(object model) : this(SerializeHelper.Serialize(model))
35         {
36 
37         }
38         public JsonResult(string json) : this(json, Encoding.UTF8)
39         {
40 
41         }
42 
43         public JsonResult(string json, HttpStatusCode status)
44         {
45             this.Content = json;
46             this.ContentEncoding = Encoding.UTF8;
47             this.ContentType = "application/json; charset=utf-8";
48             this.Status = status;
49         }
50 
51         public JsonResult(string json, Encoding encoding, string contentType = "application/json; charset=utf-8")
52         {
53             this.Content = json;
54             this.ContentEncoding = encoding;
55             this.ContentType = contentType;
56         }
57     }
58 }

　　七、RouteTable：MVC里面有一个相当重要的概念叫约定优先，即为Controller、Action的名称是按某种规则来写编码的，其中将URL与自定义Controller对应起来的缓存映射就是RouteTable，并且作为缓存，也能极大的提升访问性能。当然这里并没有严格按照asp.net mvc里面的routetable来设计，而是根据只是实现webapi，并使用缓存反射结构能来实现的，并且只有约定，没有配置。

  1 /****************************************************************************
  2 *Copyright (c) 2018 Microsoft All Rights Reserved.
  3 *CLR版本： 4.0.30319.42000
  4 *机器名称：WENLI-PC
  5 *公司名称：Microsoft
  6 *命名空间：SAEA.WebAPI.Mvc
  7 *文件名： RouteTable
  8 *版本号： V1.0.0.0
  9 *唯一标识：1ed5d381-d7ce-4ea3-b8b5-c32f581ad49f
 10 *当前的用户域：WENLI-PC
 11 *创建人： yswenli
 12 *电子邮箱：[email protected]
 13 *创建时间：2018/4/12 10:55:31
 14 *描述：
 15 *
 16 *=====================================================================
 17 *修改标记
 18 *修改时间：2018/4/12 10:55:31
 19 *修改人： yswenli
 20 *版本号： V1.0.0.0
 21 *描述：
 22 *
 23 *****************************************************************************/
 24 using System;
 25 using System.Collections.Generic;
 26 using System.Linq;
 27 using System.Reflection;
 28 using System.Text;
 29 
 30 namespace SAEA.WebAPI.Mvc
 31 {
 32     /// 
 33     /// SAEA.WebAPI路由表
 34     /// 
 35     public static class RouteTable
 36     {
 37         static object _locker = new object();
 38 
 39         static List _list = new List();
 40 
 41 
 42         /// 
 43         /// 获取routing中的缓存
 44         /// 若不存在则创建
 45         /// 
 46         /// 
 47         /// 
 48         /// 
 49         /// 
 50         /// 
 51         public static Routing TryGet(Type controllerType, string controllerName, string actionName, bool isPost)
 52         {
 53             lock (_locker)
 54             {
 55                 var list = _list.Where(b => b.ControllerName.ToLower() == controllerName.ToLower() && b.ActionName.ToLower() == actionName.ToLower() && b.IsPost == isPost).ToList();
 56 
 57                 if (list == null || list.Count == 0)
 58                 {
 59                     var routing = new Routing()
 60                     {
 61                         ControllerName = controllerName,
 62                         ActionName = actionName,
 63                         IsPost = isPost
 64                     };
 65 
 66                     var actions = controllerType.GetMethods().Where(b => b.Name.ToLower() == actionName.ToLower()).ToList();
 67 
 68                     if (actions == null || actions.Count == 0)
 69                     {
 70                         throw new Exception($"{controllerName}/{actionName}找不到此action!");
 71                     }
 72                     else if (actions.Count > 2)
 73                     {
 74                         throw new Exception($"{controllerName}/{actionName}有多个重复的的action!");
 75                     }
 76                     else
 77                     {                        
 78                         routing.Instance = System.Activator.CreateInstance(controllerType);
 79 
 80                         //类上面的过滤
 81                         var attrs = controllerType.GetCustomAttributes(true);
 82 
 83                         if (attrs != null)
 84                         {
 85                             var attr = attrs.Where(b => b.GetType().BaseType.Name == "ActionFilterAttribute").FirstOrDefault();
 86 
 87                             routing.Atrr = attr;
 88 
 89                         }
 90                         else
 91                         {
 92                             routing.Atrr = null;
 93                         }
 94 
 95                         routing.Action = actions[0];
 96 
 97                         //action上面的过滤
 98                         if (routing.Atrr == null)
 99                         {
100                             attrs = actions[0].GetCustomAttributes(true);
101 
102                             if (attrs != null)
103                             {
104                                 var attr = attrs.Where(b => b.GetType().BaseType.Name == "ActionFilterAttribute").FirstOrDefault();
105 
106                                 routing.Atrr = attr;
107 
108                             }
109                             else
110                             {
111                                 routing.Atrr = null;
112                             }
113                         }
114                     }
115                     _list.Add(routing);
116                     return routing;
117                 }
118                 else if (list.Count > 1)
119                 {
120                     throw new Exception("500");
121                 }
122                 return list.FirstOrDefault();
123             }
124         }
125     }
126 
127 }

　　在MVC的思想里面ActionFilterAtrribute的这个AOP设计也一直伴随左右，比如记日志、黑名单、权限、验证、限流等等功能，所以路由的时候也会缓存这个。至此一些关键性的地方都已经弄的差不多了，为了更好的了解上面说的这些，下面是vs2017中项目的结构截图：

　　纯粹干净单码，无任何晦涩内容，如果对mvc有一定了解的，这个差不多可以NoNotes，接下来就是按asp.net mvc命名方式，写个测试webapi看看情况，首先还是测试项目结构图：

　　HomeController里面按asp.net mvc的习惯来编写代码：

  1 /****************************************************************************
  2 *Copyright (c) 2018 Microsoft All Rights Reserved.
  3 *CLR版本： 4.0.30319.42000
  4 *机器名称：WENLI-PC
  5 *公司名称：Microsoft
  6 *命名空间：SAEA.WebAPITest.Controllers
  7 *文件名： HomeController
  8 *版本号： V1.0.0.0
  9 *唯一标识：e00bb57f-e3ee-4efe-a7cf-f23db767c1d0
 10 *当前的用户域：WENLI-PC
 11 *创建人： yswenli
 12 *电子邮箱：[email protected]
 13 *创建时间：2018/4/10 16:43:26
 14 *描述：
 15 *
 16 *=====================================================================
 17 *修改标记
 18 *修改时间：2018/4/10 16:43:26
 19 *修改人： yswenli
 20 *版本号： V1.0.0.0
 21 *描述：
 22 *
 23 *****************************************************************************/
 24 using SAEA.WebAPI.Mvc;
 25 using SAEA.WebAPITest.Attrubutes;
 26 using SAEA.WebAPITest.Model;
 27 
 28 namespace SAEA.WebAPITest.Controllers
 29 {
 30     /// 
 31     /// 测试实例代码
 32     /// 
 33     //[LogAtrribute]
 34     public class HomeController : Controller
 35     {
 36         /// 
 37         /// 日志拦截
 38         /// 内容输出
 39         /// 
 40         /// 
 41         //[Log2Atrribute]
 42         public ActionResult Index()
 43         {
 44             return Content("Hello,I'm SAEA.WebAPI！");
 45         }
 46         /// 
 47         /// 支持基本类型参数
 48         /// json序列化
 49         /// 
 50         /// 
 51         /// 
 52         public ActionResult Get(int id)
 53         {
 54             return Json(new { Name = "yswenli", Sex = "男" });
 55         }
 56         /// 
 57         /// 底层对象调用
 58         /// 
 59         /// 
 60         public ActionResult Show()
 61         {
 62             var response = HttpContext.Response;
 63 
 64             response.Content_Type = "text/html; charset=utf-8";
 65 
 66             response.Write("测试一下那个response对象使用情况！参考消息网4月12日报道外媒称，法国一架“幻影-2000”战机意外地对本国一家工厂投下了...");
 67 
 68             response.End();
 69 
 70             return Empty();
 71         }
 72 
 73         [HttpGet]
 74         public ActionResult Update(int id)
 75         {
 76             return Content($"HttpGet Update id:{id}");
 77         }
 78         /// 
 79         /// 基本类型参数、实体混合填充
 80         /// 
 81         /// 
 82         /// 
 83         /// 
 84         [HttpPost]
 85         public ActionResult Update(bool isFemale, UserInfo userInfo = null)
 86         {
 87             return Json(userInfo);
 88         }
 89         [HttpPost]
 90         public ActionResult Test()
 91         {
 92             return Content("httppost test");
 93         }
 94         /// 
 95         /// 文件输出
 96         /// 
 97         /// 
 98         public ActionResult Download()
 99         {
100             return File(HttpContext.Server.MapPath("/Content/Image/c984b2fb80aeca7b15eda8c004f2e0d4.jpg"));
101         }
102     }
103 }

　　增加一个LogAtrribute打印一些内容：

 1 /****************************************************************************
 2 *Copyright (c) 2018 Microsoft All Rights Reserved.
 3 *CLR版本： 4.0.30319.42000
 4 *机器名称：WENLI-PC
 5 *公司名称：Microsoft
 6 *命名空间：SAEA.WebAPITest.Common
 7 *文件名： LogAtrribute
 8 *版本号： V1.0.0.0
 9 *唯一标识：2a261731-b8f6-47de-b2e4-aecf2e0e0c0f
10 *当前的用户域：WENLI-PC
11 *创建人： yswenli
12 *电子邮箱：[email protected]
13 *创建时间：2018/4/11 13:46:42
14 *描述：
15 *
16 *=====================================================================
17 *修改标记
18 *修改时间：2018/4/11 13:46:42
19 *修改人： yswenli
20 *版本号： V1.0.0.0
21 *描述：
22 *
23 *****************************************************************************/
24 using SAEA.Commom;
25 using SAEA.WebAPI.Http;
26 using SAEA.WebAPI.Mvc;
27 
28 namespace SAEA.WebAPITest.Attrubutes
29 {
30     public class LogAtrribute : ActionFilterAttribute
31     {
32         /// 
33         /// 执行前
34         /// 
35         /// 
36         /// 返回值true为继续，false为终止
37         public override bool OnActionExecuting(HttpContext httpContext)
38         {
39             return true;
40         }
41 
42         /// 
43         /// 执行后
44         /// 
45         /// 
46         /// 
47         public override void OnActionExecuted(HttpContext httpContext, ActionResult result)
48         {
49             ConsoleHelper.WriteLine($"请求地址：{httpContext.Request.Query},回复内容：{result.Content}");
50         }
51     }
52 }

　　program.cs Main中启动一下服务：

1 MvcApplication mvcApplication = new MvcApplication();
2 
3 mvcApplication.Start();

　　最后F5跑起来看看效果：

　　使用Apache ab.exe压测一下性能如何：

　　至此，一个简洁、高效的WebApi就初步完成了！

转载请标明本文来源：http://www.cnblogs.com/yswenli/p/8858669.html
更多内容欢迎star作者的github：https://github.com/yswenli/SAEA
如果发现本文有什么问题和任何建议，也随时欢迎交流~

感谢您的阅读，如果您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是yswenli 。

面试题随笔

innerHTML与innerText区别

innerHTML指的是从对象的起始位置到终止位置的全部内容,包括Html标签。

innerText   指的是从起始位置到终止位置的内容,但它去除Html标签。

setInterval和setTimeout的使用区别

setInterval在执行完一次代码之后，经过了那个固定的时间间隔，它还会自动重复执行代码，而setTimeout只执行一次那段代码。

MVC有几种向页面绑定数据的方法

1、指定页面数据的强类型Model
2、使用ViewData绑定到页面
3、使用ViewBag绑定到页面

字符串反转

var str = 'abcdefgh';

第一种

split()方法将一个字符串对象的每个字符拆出来，并且将每个字符串当成数组的每个元素reverse()方法用来改变数组，将数组中的元素倒个序排列，第一个数组元素成为最后一个，最后一个变成第一个join()方法将数组中的所有元素边接成一个字符串

 console.log(str.split('').reverse().join(''));

第二种

for循环给原字符串做一个递减遍历，然后将遍历的字符串重新合并成一个新字符串


function reverse2() {
   var str2 = ''; for (var i >= 0; i = str.length - 1;i--){ str2 += str[i]; } console.log(str2); } reverse2();

第三种

 function reverse3(str){
    var arr = str.split(''); var i = 0,j = arr.length-1; while(iconsole.log(arr.join("")) return arr.join(""); } reverse3(str);

再提供两种方式：
直接string.Concat(str.Reverse())
或使用Stack也可以

转载于:https://www.cnblogs.com/cjm123/p/9222083.html

你可能感兴趣的:(测试,c#,json)

C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
398顺境，逆境戴骁勇
2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
CX8836：小体积大功率升降压方案推荐（附Demo设计指南）诚芯微科技社交电子
CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
【华为OD技术面试真题 - 技术面】-测试八股文真题题库（1）算法大师华为od 面试 python 算法前端
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.黑盒测试和白盒测试的区别2.假设我们公司现在开发一个类似于微信的软件1.0版本，现在要你测试这个功能：打开聊天窗口，输入文本，限制字数在200字以内。问你怎么提取测试点。功能测试性能测试安全性测试可用性测试跨平台兼容性测试网络环境测试3.接口测试的工具你了解哪些
docker igotyback eureka 云原生
Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
在Ubuntu中编译含有JSON的文件出现报错芝麻糊76 Linux kill_bug linux ubuntu json
在ubuntu中进行JSON相关学习的时候，我发现了一些小问题，决定与大家进行分享，减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
Xinference如何注册自定义模型玩人工智能的辣条哥人工智能 AI 大模型 Xinference
环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
你可能遗漏的一些C#/.NET/.NET Core知识点追逐时光者 C#.NET DotNetGuide编程指南 c#.net .netcore microsoft
前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
第1步win10宿主机与虚拟机通过NAT共享上网互通学习3人组大数据大数据
VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
spring如何整合druid连接池？惜.己 spring spring junit 数据库 java idea 后端 xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
Python神器！WEB自动化测试集成工具 DrissionPage 亚丁号 python 开发语言
一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）疯狂的机器人 Python搞定车载自动化 python DoIP UDS ISO 14229 1SO 13400 Bootloader tcp/ip
系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
更改npm镜像源为淘宝镜像骆小骆基于node.js
npm常用指令后缀*最近复习了一下node.js整理了一下跟node.js相关的指令后缀*--save、-S参数意思是把模块的版本信息保存到dependencies（生产环境依赖）中，即你的package.json文件的dependencies字段中；–--save-dev、-D参数意思是把模块版本信息保存到devDependencies（开发环境依赖）中，即你的package.json文件的de
COCO 格式的数据集转化为 YOLO 格式的数据集 QYQY77 YOLO python
"""--json_path输入的json文件路径--save_path保存的文件夹名字，默认为当前目录下的labels。"""importosimportjsonfromtqdmimporttqdmimportargparseparser=argparse.ArgumentParser()parser.add_argument('--json_path',default='./instances
Python 课程10-单元测试可愛小吉 Python教學 python 单元测试开发语言 TDD unittest
前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
【自动化测试】UI自动化的分类、如何选择合适的自动化测试工具以及其中appium的设计理念、引擎和引擎如何工作 Lossya ui 自动化测试工具自动化测试 appium
引言UI自动化测试主要针对软件的用户界面进行测试，以确保用户界面元素的交互和功能符合预期文章目录引言一、UI自动化的分类1.1基于代码的自动化测试1.2基于录制/回放的自动化测试1.3基于框架的自动化测试1.4按测试对象分类1.5按测试层次分类1.6按测试执行方式分类1.7按测试目的分类二、如何选择合适的自动化测试工具2.1项目需求分析2.2工具特性评估2.3成本考虑2.4团队技能2.5试用和评估
微信小程序开发注意事项 jun778895 微信小程序小程序
微信小程序开发是一个融合了前端开发、用户体验设计、后端服务（可选）以及微信小程序平台特性的综合性项目。这里，我将详细介绍一个典型的小程序开发项目的全过程，包括项目规划、设计、开发、测试及部署上线等各个环节，并尽量使内容达到或超过2000字的要求。一、项目规划1.1项目背景与目标假设我们要开发一个名为“智慧校园助手”的微信小程序，旨在为学生提供一站式校园生活服务，包括课程表查询、图书馆座位预约、食堂
性格小测试熹大头
有些人非常肯定自己属于外向型，有些人则发现自己是绝对的内向型。然而，多数人却发现他们似乎介于两者之间，是两种性格的结合。现在我们就来看看你在这种分类中处在何种位置。阅读以下问题，从a、b、c中选出最适合自己的选项。你可能会发现三个选项都不合适，或者合适的不止一项，这种情况下，选出相对来说更适合自己的即可。1人们经常会用下列哪个词语描述你：a善于分析b遵守纪律c有创造力2一连几天参与社交活动（比如，
golang获取用户输入的几种方式余生逆风飞翔 golang 开发语言后端
一、定义结构体typeUserInfostruct{Namestring`json:"name"`Ageint`json:"age"`Addstring`json:"add"`}typeReturnDatastruct{Messagestring`json:"message"`Statusstring`json:"status"`DataUserInfo`json:"data"`}二、get请求的
Sissi书单｜《每天刷本书》365天不间断阅读第28天每天刷的sissi
以前我是一个不太会和自己对话的人，但是后来经历得多了，就慢慢变得喜欢自省起来。喜欢通过做各种测试题来更好的了解自己。测出来什么点，我觉得需要改善，就会到处去找调整的方法。这本书就是我在找方法的时候看到的，看的过程中除了觉得有用，还是觉得有用，非常推荐阅读！
spring mvc @RequestBody String类型参数 zoyation spring-mvc spring mvc
通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
macOs mojave 添加hp laserjet 1020 打印机方法。 Coder_Zh
1.设置--》打印机与扫描仪。2.点击“+”选择IP3.输入地址：（写网络IP），协议选择：hpjetdirect-socket4.使用选项：选择hplaserjet10221.6（没有1020的驱动，但是1022的驱动兼容1020可以使用。）测试OK，可以使用。
接口测试如何设计测试用例李蕴Ronnie
接口测试用例设计方式针对每个必填参数，都设计一条参数为空的测试用例必填参数不存在传的参数值在数据库中不存在添加数据接口，传入已有的数据重复添加编辑数据接口，各个字段分别编辑，合并编辑参数数据类型限制，针对每个参数设计一条参数值类型不符合的逆向用例参数自身取值范围，针对所有参数，设计一条每个参数值在取值范围内最大值的正向测试用例是否满足前提条件（token、headers），几个前提条件几条用例针对
【Death Note】网吧战神之7天爆肝渗透测试死亡笔记_sqlmap在默认情况下除了使用 char() 函数防止出现单引号 2401_84561374 程序员笔记
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！特殊服务端口2181zookeeper服务未授权访问
C#动态加载DLL程序集及使用反射创建实例-简记不全 C#相关 Asp.net WebForm Asp.net MVC c#Assembly 反射程序集
Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
二十四、k8s 资源管理繁华依在 k8s kubernetes 容器云原生
目录一、资源配置范围管理LimitRange介绍1、LimitRange可以做什么：2、资源限制和请求的约束3、创建LimitsRange对象4、示例：创建一个pod5、测试用例测试1：测试2：测试3：二、资源服务质量管理（RequestsQos）1、Qos级别分类：1.1、Guaranteed：1.2、BestEffort：1.3、Burstable：2、Qos的工作特点3、示例三、资源配额管理
python可以制作大型游戏_python能做游戏吗-python能开发游戏吗靖dede python可以制作大型游戏
python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
HQL之投影查询归来朝歌 HQL Hibernate 查询语句投影查询
在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
Spring整合redis bylijinnan redis
pom.xml <dependencies>  <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2 在项目中出现了org.hiber
android动画效果不懂事的小屁孩 android动画
前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
js delete 删除机理以及它的内存泄露问题的解决方案换个号韩国红果果 JavaScript
delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露（其实还未删除）举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
Oracle将零干预分析加入网络即服务计划蓝儿唯美 oracle
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
spring学习——springmvc（二） a-john springMVC
Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
POJ-2828-Buy Tickets aijuans ACM_POJ
POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
Java Ant build.xml详解 asia007 build.xml
1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台 --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
android按钮监听器的四种技术百合不是茶 android xml配置监听器实现接口
android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方; 1,activity中使用内部类实现接口 ,创建内部类实例使用add方法与java类似创建监听器的实例 myLis lis = new myLis(); 使用add方法给按钮添加监听器
软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。如今很多的公司
TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForge How do Attachement Anchor Wiki Syntax
the CollabNet user information center http://help.collab.net/ How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
【Redis四】Redis数据类型 bit1129 redis
概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
SSH2整合-附源码白糖_ eclipse spring tomcat Hibernate Google
今天用eclipse终于整合出了struts2+hibernate+spring框架。我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。补充1：项目中部分jar包不是最新版的，可能导
[转]开源项目代码的学习方法 braveCS 学习方法
转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
编程之美-子数组的最大和（二维） bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
读书笔记-3 chengxuyuancsdn jquery笔记 resultMap配置 ibatis一对多配置
1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
[物理与天文]物理学新进展 comsci
如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境怎么办呢?
Oracle 11g新特性:Automatic Diagnostic Repository daizj oracle ADR
Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。这两份log文
简单排序:选择排序 dieslrae 选择排序
public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
线程同步工具类 shuizhaosi888 同步工具类
同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
bleeding edge是什么意思 haojinghua DI
不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 In computer science, bleeding edge is a term that
c中实现utf8和gbk的互转 jimmee c iconv utf8&gbk编码
#include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
在代码中获取Android theme中的attr属性值 OliveExcel android theme
Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
基于Zookeeper的分布式共享锁 roadrunners zookeeper 分布式共享锁
首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。官
两个容易被忽略的MySQL知识 tomcat_oracle mysql
1、varchar(5)可以存储多少个汉字，多少个字母数字？　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
zoj 3827 Information Entropy(水题) 阿尔萨斯 format
题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&

线程安全使用（四） [.NET] 简单接入微信公众号开发：实现自动回复 [C#]C#中字符串的操作 自行实现比dotcore/dotnet更方便更高性能的对象二进制序列化 自已动手做高性能消息...