zhusenlin/serein-flow
1
0
Fork 0
mirror of https://gitee.com/langsisi_admin/serein-flow synced 2026-03-02 15:50:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

重新设计了Libray.Json Api以及 WebSocket 的交互处理方式

Browse Source
This commit is contained in:
fengjiayi
2025-08-02 10:48:31 +08:00
parent 1bccccc835
commit 6fc57458a7
29 changed files with 883 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
Library/Api/IJsonProvider.cs
View File

@@ -7,11 +7,36 @@ using System.Threading.Tasks;
namespace Serein.Library.Api
{
/// <summary>
/// JSON数据交互的Token接口，允许使用不同的JSON库进行数据处理。
/// </summary>
public interface IJsonToken
{
/// <summary>
/// 获取当前Token的类型，可能是值、对象或数组。
/// </summary>
TokenType Type { get; }
/// <summary>
/// 获取当前Token的类型，可能是值、对象或数组。
/// </summary>
public enum TokenType
{
/// <summary>
/// 表示一个值类型的Token，例如字符串、数字或布尔值。
/// </summary>
Value,
/// <summary>
/// 表示一个对象类型的Token，通常是一个键值对集合。
/// </summary>
Object,
/// <summary>
/// 表示一个数组类型的Token，通常是一个元素列表。
/// </summary>
Array,
}
/// <summary>
/// 获取 Token
/// </summary>
@@ -19,12 +44,6 @@ namespace Serein.Library.Api
/// <returns></returns>
IJsonToken this[object name] { get; }
/* /// <summary>
/// 获取 Token 数组的元素，允许通过索引访问数组中的元素。
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
IJsonToken this[int index] { get; }*/
/// <summary>
/// 获取指定名称的属性，如果存在则返回true，并通过out参数返回对应的IJsonToken对象。

9
Library/ScriptBaseFunc.cs
View File

@@ -145,15 +145,14 @@ namespace Serein.Library
/// <returns></returns>
public static IJsonToken json(string content)
{
/*if (string.IsNullOrWhiteSpace(content))
{
return JsonHelper.Object(dict => { }) ;
}*/
return JsonHelper.Parse(content);
}
#endregion

1
Library/Utils/JsonHelper.cs
View File

@@ -56,7 +56,6 @@ namespace Serein.Library.Utils
public static IJsonToken Parse(string json)
{
return provider.Parse(json);
}
/// <summary>

3
Serein.Extend.NewtonsoftJson/NewtonsoftJsonArrayToken.cs
View File

@@ -6,11 +6,14 @@ using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Serein.Library.Api.IJsonToken;
namespace Serein.Extend.NewtonsoftJson
{
public sealed class NewtonsoftJsonArrayToken : IJsonToken, IList<IJsonToken>
{
public TokenType Type => TokenType.Array;
private readonly JArray _array;
public NewtonsoftJsonArrayToken(JArray array) => _array = array;

3
Serein.Extend.NewtonsoftJson/NewtonsoftJsonObjectToken.cs
View File

@@ -5,6 +5,7 @@ using Serein.Library.Utils;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using static Serein.Library.Api.IJsonToken;
namespace Serein.Extend.NewtonsoftJson
{
@@ -13,6 +14,8 @@ namespace Serein.Extend.NewtonsoftJson
/// </summary>
public sealed class NewtonsoftJsonObjectToken : IJsonToken, IDictionary<string, IJsonToken>
{
public TokenType Type => TokenType.Object;
private readonly JObject _object;
public NewtonsoftJsonObjectToken(JObject obj) => _object = obj;

3
Serein.Extend.NewtonsoftJson/NewtonsoftJsonValueToken.cs
View File

@@ -6,11 +6,14 @@ using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Serein.Library.Api.IJsonToken;
namespace Serein.Extend.NewtonsoftJson
{
public sealed class NewtonsoftJsonValueToken : IJsonToken
{
public TokenType Type => TokenType.Value;
private readonly JToken _token;
public NewtonsoftJsonValueToken(JToken token)

15
Serein.Proto.WebSocket/Attributes/SendAttribute.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.Proto.WebSocket.Attributes
{
/// <summary>
/// 指示需要发送消息的处理方法
/// </summary>
public sealed class SendAttribute : Attribute
{
}
}

5
Serein.Proto.WebSocket/Attributes/UseRequestAttribute.cs
View File

@@ -6,7 +6,10 @@ using System.Threading.Tasks;
namespace Serein.Proto.WebSocket.Attributes
{
internal sealed class UseRequestAttribute : Attribute
/// <summary>
/// 指示使用 WebSocket 中请求的整体数据
/// </summary>
public sealed class UseRequestAttribute : Attribute
{
}
}

6
Serein.Proto.WebSocket/Attributes/AutoSocketModuleAttribute.cs → Serein.Proto.WebSocket/Attributes/WebSocketModuleAttribute.cs
View File

@@ -1,8 +1,8 @@
namespace Serein.Proto.WebSocket.Attributes
{
/// <summary>
/// <para>标记该类是处理模板，需要获取WebSocketServer/WebSocketClient了实例后，使用(Server/Client).MsgHandleHelper.AddModule()进行添加。</para>
/// <para>处理模板需要继承 ISocketHandleModule 接口，否则WebSocket接受到数据时，将无法进行调用相应的处理模板。</para>
/// <para>标记该类是处理模板</para>
/// <para>处理模板需要继承 ISocketHandleModule 接口，否则接受到 WebSocket 数据时，将无法进行调用相应的处理模板。</para>
/// <para>使用方式：</para>
/// <para>[AutoSocketModule(ThemeKey = "theme", DataKey = "data")]</para>
/// <para>public class PlcSocketService : ISocketHandleModule</para>
@@ -16,7 +16,7 @@
/// <para></para>
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
public sealed class AutoSocketModuleAttribute : Attribute
public sealed class WebSocketModuleAttribute : Attribute
{
/// <summary>
/// 业务标识

8
Serein.Proto.WebSocket/Attributes/AutoSocketHandleAttribute.cs → Serein.Proto.WebSocket/Attributes/WsMethodAttribute.cs
View File

@@ -16,7 +16,7 @@
/// <para>Func&lt;dynamic,Task&gt; : 会自动将对象解析为Json字符串，异步发送文本内容。</para>
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
public sealed class AutoSocketHandleAttribute : Attribute
public sealed class WsMethodAttribute : Attribute
{
/// <summary>
/// 描述Json业务字段，如果不设置，将默认使用方法名称。
@@ -32,12 +32,6 @@
/// <para>会进行异步等待，当Task结束后，自动获取TResult进行发送（请避免Task&lt;Task&lt;TResult&gt;&gt;诸如此类的Task泛型嵌套）</para>
/// </summary>
public bool IsReturnValue = true;
/// <summary>
/// <para>表示该方法所有入参不能为空（所需的参数在请求Json的Data不存在）</para>
/// <para>若有一个参数无法从data获取，则不会进行调用该方法</para>
/// <para>如果设置该属性为 false ，但某些入参不能为空，而不希望在代码中进行检查，请为入参添加[NotNull]/[Needful]特性</para>
/// </summary>
public bool ArgNotNull = true;
}

14
Serein.Proto.WebSocket/Handle/Attribute.cs
View File

@@ -1,14 +0,0 @@
using System;
namespace Serein.Proto.WebSocket.Handle
{
/// <summary>
/// 表示参数不能为空(Net462不能使用NutNull的情况）
/// </summary>
public sealed class NeedfulAttribute : Attribute
{
}
}

33
Serein.Proto.WebSocket/Handle/HandleConfiguration.cs → Serein.Proto.WebSocket/Handle/MethodInvokeConfiguration.cs
View File

@@ -1,4 +1,5 @@
using Serein.Library;
using static Serein.Proto.WebSocket.SereinWebSocketService;
@@ -8,18 +9,13 @@ namespace Serein.Proto.WebSocket.Handle
/// socket模块处理数据配置
/// </summary>
public class HandleConfiguration
public class MethodInvokeConfiguration
{
/// <summary>
/// Emit委托
/// </summary>
public DelegateDetails? DelegateDetails { get; set; }
/// <summary>
/// 未捕获的异常跟踪
/// </summary>
public Action<Exception, Action<object>>? OnExceptionTracking { get; set; }
/// <summary>
/// 所使用的实例
/// </summary>
@@ -30,11 +26,6 @@ namespace Serein.Proto.WebSocket.Handle
/// </summary>
public bool IsReturnValue { get; set; } = true;
/// <summary>
/// 是否要求必须不为null
/// </summary>
public bool ArgNotNull { get; set; } = true;
/// <summary>
/// 是否使用Data整体内容作为入参参数
/// </summary>
@@ -45,6 +36,21 @@ namespace Serein.Proto.WebSocket.Handle
/// </summary>
public bool[] UseRequest { get; set; } = [];
/// <summary>
/// 是否需要发送消息的委托
/// </summary>
public bool[] IsNeedSendDelegate { get; set; } = [];
/// <summary>
/// 发送消息的委托类型
/// </summary>
public SendType[] SendDelegateType { get; set; } = [];
/// <summary>
/// 缓存的发送委托数组
/// </summary>
public Delegate?[] CachedSendDelegates ;
/// <summary>
/// 是否使用消息ID作为入参参数
/// </summary>
@@ -60,11 +66,6 @@ namespace Serein.Proto.WebSocket.Handle
/// </summary>
public Type[] ParameterType { get; set; } = [];
/// <summary>
/// 是否检查变量为空
/// </summary>
public bool[] IsCheckArgNotNull { get; set; } = [];
}

247
Serein.Proto.WebSocket/Handle/WebSocketHandleModule.cs
View File

@@ -1,8 +1,10 @@
using Serein.Library;
using Serein.Library.Api;
using Serein.Library.Utils;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text.Json.Nodes;
using System.Threading.Tasks;
namespace Serein.Proto.WebSocket.Handle
@@ -16,35 +18,38 @@ namespace Serein.Proto.WebSocket.Handle
/// <summary>
/// Json消息处理模块
/// </summary>
public WebSocketHandleModule(WebSocketHandleModuleConfig config)
public WebSocketHandleModule(WebSocketModuleConfig config)
{
moduleConfig = config;
_moduleConfig = config;
_methodInvokeConfigs = new ConcurrentDictionary<string, MethodInvokeConfiguration>();
_myMsgIdHash = new HashSet<string>();
}
/// <summary>
/// 模块的处理配置
/// </summary>
private readonly WebSocketHandleModuleConfig moduleConfig;
private readonly WebSocketModuleConfig _moduleConfig;
/// <summary>
/// 用来判断消息是否重复
/// </summary>
private HashSet<string> _myMsgIdHash = new HashSet<string>();
private readonly HashSet<string> _myMsgIdHash;
/// <summary>
/// 存储处理数据的配置
/// </summary>
public ConcurrentDictionary<string, HandleConfiguration> MyHandleConfigs = new ConcurrentDictionary<string, HandleConfiguration>();
private readonly ConcurrentDictionary<string, MethodInvokeConfiguration> _methodInvokeConfigs ;
/// <summary>
/// 添加处理配置
/// </summary>
/// <param name="config">处理模块</param>
internal bool AddHandleConfigs(WebSocketHandleConfiguration config)
internal bool AddHandleConfigs(WebSocketMethodConfig config)
{
if (!MyHandleConfigs.ContainsKey(config.ThemeValue))
if (!_methodInvokeConfigs.ContainsKey(config.ThemeValue))
{
MyHandleConfigs[config.ThemeValue] = config;
_methodInvokeConfigs[config.ThemeValue] = config;
return true;
}
else
@@ -60,13 +65,13 @@ namespace Serein.Proto.WebSocket.Handle
/// <returns></returns>
public bool RemoveConfig(ISocketHandleModule socketControlBase)
{
foreach (var kv in MyHandleConfigs.ToArray())
foreach (var kv in _methodInvokeConfigs.ToArray())
{
var config = kv.Value;
MyHandleConfigs.TryRemove(kv.Key, out _);
_methodInvokeConfigs.TryRemove(kv.Key, out _);
}
return MyHandleConfigs.Count == 0;
return _methodInvokeConfigs.Count == 0;
}
/// <summary>
@@ -74,8 +79,8 @@ namespace Serein.Proto.WebSocket.Handle
/// </summary>
public void UnloadConfig()
{
var temp = MyHandleConfigs.Values;
MyHandleConfigs.Clear();
var temp = _methodInvokeConfigs.Values;
_methodInvokeConfigs.Clear();
}
@@ -83,46 +88,64 @@ namespace Serein.Proto.WebSocket.Handle
/// <summary>
/// 处理JSON数据
/// </summary>
public async Task HandleAsync(WebSocketMsgContext context)
public async Task HandleAsync(WebSocketHandleContext context)
{
var jsonObject = context.MsgRequest; // 获取到消息
if (jsonObject is null)
{
// SereinEnv.WriteLine(InfoType.WARN, "没有获取到消息");
context.TriggerExceptionTracking($"请求没有获取到消息");
return; // 没有获取到消息
}
if(!jsonObject.TryGetValue(_moduleConfig.ThemeJsonKey, out var themeToken) || themeToken.IsNull)
{
context.TriggerExceptionTracking($"请求没有获取到主题\"{_moduleConfig.ThemeJsonKey}\"");
return; // 没有获取到消息
}
if(themeToken.Type != IJsonToken.TokenType.Value)
{
context.TriggerExceptionTracking($"请求主题需要值类型 \"{_moduleConfig.ThemeJsonKey}\"");
return; // 没有获取到消息
}
var theme = themeToken.ToString(); // 获取主题
// 验证主题
if (!jsonObject.TryGetValue(moduleConfig.ThemeJsonKey, out var themeToken)
|| themeToken.ToString() is not string theme
|| !MyHandleConfigs.TryGetValue(theme, out var handldConfig))
if (!_methodInvokeConfigs.TryGetValue(theme, out var handldConfig))
{
// SereinEnv.WriteLine(InfoType.WARN, $"{theme} 主题不存在");
context.TriggerExceptionTracking($"{_moduleConfig.ThemeJsonKey} 主题不存在");
return;
}
// 验证消息ID
if (!jsonObject.TryGetValue(moduleConfig.MsgIdJsonKey, out var msgIdToken)
|| msgIdToken.ToString() is not string msgId)
if (!jsonObject.TryGetValue(_moduleConfig.MsgIdJsonKey, out var msgIdToken) || themeToken.IsNull)
{
// SereinEnv.WriteLine(InfoType.WARN, $"[{msgId}]{theme} 没有消息Id");
return;
context.TriggerExceptionTracking($"主题 {theme} 没有消息Id");
return; // 没有获取到消息
}
if (themeToken.Type != IJsonToken.TokenType.Value)
{
context.TriggerExceptionTracking($"请求消息Id需要值类型 \"{_moduleConfig.ThemeJsonKey}\"");
return; // 没有获取到消息
}
var msgId = msgIdToken.ToString(); // 获取主题
// 验证消息ID是否重复
if (!_myMsgIdHash.Add(msgId))
{
// SereinEnv.WriteLine(InfoType.WARN, $"[{msgId}]{theme} 消息重复");
context.TriggerExceptionTracking($"主题 {theme} 消息Id {msgId} 消息重复");
return; // 消息重复
}
// 验证数据
if (!jsonObject.TryGetValue(moduleConfig.DataJsonKey, out var dataToken))
if (!jsonObject.TryGetValue(_moduleConfig.DataJsonKey, out var dataToken))
{
// SereinEnv.WriteLine(InfoType.WARN, $"[{msgId}]{theme} 消息重复");
context.TriggerExceptionTracking($"主题 {theme} 消息Id {msgId} 数据提取失败，当前指定键\"{_moduleConfig.DataJsonKey}\"");
return; // 没有主题
}
if(dataToken.Type != IJsonToken.TokenType.Object)
{
context.TriggerExceptionTracking($"主题 {theme} 消息Id {msgId} 数据需要 JSON Object");
}
context.MsgTheme = theme; // 添加主题
context.MsgId = msgId; // 添加 ID
@@ -135,17 +158,17 @@ namespace Serein.Proto.WebSocket.Handle
var result = await HandleAsync(handldConfig, args);
if (handldConfig.IsReturnValue)
{
await context.RepliedAsync(moduleConfig, context, result);
await RepliedAsync(_moduleConfig, context, result);
}
}
else
{
SereinEnv.WriteLine(InfoType.WARN, $"[{msgId}]{theme} 参数获取失败");
context.TriggerExceptionTracking($"主题 {theme} 消息Id {msgId} 参数获取失败");
}
}
catch (Exception ex)
{
SereinEnv.WriteLine(InfoType.ERROR, $"error in ws : {ex.Message}{Environment.NewLine}json value:{jsonObject}");
context.TriggerExceptionTracking(ex);
}
finally
{
@@ -153,6 +176,7 @@ namespace Serein.Proto.WebSocket.Handle
}
}
/// <summary>
/// 调用
@@ -160,7 +184,7 @@ namespace Serein.Proto.WebSocket.Handle
/// <param name="config"></param>
/// <param name="args"></param>
/// <returns></returns>
public static async Task<object> HandleAsync(HandleConfiguration config, object?[] args)
public static async Task<object> HandleAsync(MethodInvokeConfiguration config, object?[] args)
{
if (config.DelegateDetails is null)
{
@@ -179,14 +203,15 @@ namespace Serein.Proto.WebSocket.Handle
/// <param name="context">处理上下文</param>
/// <param name="args">返回的入参参数</param>
/// <returns></returns>
internal static bool TryGetParameters(HandleConfiguration config, WebSocketMsgContext context, out object?[] args)
internal static bool TryGetParameters(MethodInvokeConfiguration config, WebSocketHandleContext context, out object?[] args)
{
args = new object[config.ParameterType.Length];
var theme = context.MsgTheme;
var msgId = context.MsgId;
List<string> exTips = [$"主题 {theme} 消息Id {msgId}"];
bool isCanInvoke = true; ; // 表示是否可以调用方法
for (int i = 0; i < config.ParameterType.Length; i++)
{
var type = config.ParameterType[i]; // 入参变量类型
var argName = config.ParameterName[i]; // 入参参数名称
#region 传递消息ID
@@ -207,93 +232,123 @@ namespace Serein.Proto.WebSocket.Handle
args[i] = context.MsgData?.ToObject(type);
}
#endregion
#region 值类型参数
else if (type.IsValueType)
#region 入参参数
else if (!config.IsNeedSendDelegate[i])
{
var jsonValue = context.MsgData?.GetValue(argName);
if (jsonValue is not null)
if(jsonValue is null)
{
args[i] = jsonValue.ToObject(type);
isCanInvoke = false;
exTips.Add($"参数 {argName}({i}) 不存在，请检查参数名称是否正确");
continue;
}
else
var data = jsonValue.ToObject(type);
if (data is null)
{
if (config.ArgNotNull && !config.IsCheckArgNotNull[i]) // 检查不能为空
{
args[i] = Activator.CreateInstance(type); // 值类型返回默认值
}
else
{
isCanInvoke = false; // 参数不能为空，终止调用
break;
}
}
}
#endregion
#region 引用类型参数
else if (type.IsClass)
{
var jsonValue = context.MsgData?.GetValue(argName);
if (!(jsonValue is null))
{
args[i] = jsonValue.ToObject(type);
}
else
{
if (!config.ArgNotNull && !config.IsCheckArgNotNull[i])
{
args[i] = null; // 引用类型返回null
}
else
{
isCanInvoke = false; // 参数不能为空，终止调用
break;
}
isCanInvoke = false;
exTips.Add($"参数 {argName}({i}) 解析失败，类型：{type.FullName}，值：{jsonValue}，请检查参数类型是否正确");
continue;
}
args[i] = data;
}
#endregion
#region 传递消息委托
else if (type.IsGenericType) // 传递SendAsync委托
else if (config.IsNeedSendDelegate[i]) // 传递SendAsync委托
{
if (type.IsAssignableFrom(typeof(Func<object, Task>)))
if (config.CachedSendDelegates != null && config.CachedSendDelegates[i] != null)
{
args[i] = new Func<object, Task>(async data =>
{
var jsonText = JsonHelper.Serialize(data);
await context.SendAsync(jsonText);
});
args[i] = config.CachedSendDelegates[i];
continue;
}
else if (type.IsAssignableFrom(typeof(Func<string, Task>)))
Delegate? del = null;
var st = config.SendDelegateType[i];
switch (st)
{
args[i] = new Func<string, Task>(async data =>
{
await context.SendAsync(data);
});
case SereinWebSocketService.SendType.ObjectAsync:
del = new Func<object, Task>(async data =>
{
var jsonText = JsonHelper.Serialize(data);
await context.SendAsync(jsonText);
});
break;
case SereinWebSocketService.SendType.StringAsync:
del = new Func<string, Task>(async data =>
{
await context.SendAsync(data);
});
break;
case SereinWebSocketService.SendType.Object:
del = new Action<object>(data =>
{
var jsonText = JsonHelper.Serialize(data);
_ = context.SendAsync(jsonText);
});
break;
case SereinWebSocketService.SendType.String:
del = new Action<string>(data =>
{
_ = context.SendAsync(data);
});
break;
}
else if (type.IsAssignableFrom(typeof(Action<object>)))
if (del is not null)
{
args[i] = new Action<object>(async data =>
{
var jsonText = JsonHelper.Serialize(data);
await context.SendAsync(jsonText);
});
config.CachedSendDelegates![i] = del;
args[i] = del;
}
else if (type.IsAssignableFrom(typeof(Action<string>)))
else
{
args[i] = new Action<string>(async data =>
{
var jsonText = JsonHelper.Serialize(data);
await context.SendAsync(jsonText);
});
isCanInvoke = false; // 方法要求参数不能为空，终止调用
exTips.Add($"参数 {argName}({i}) 发送委托类型错误");
break;
}
}
#endregion
}
if (!isCanInvoke)
{
string ex = string.Join(Environment.NewLine, exTips);
context.TriggerExceptionTracking(ex);
}
return isCanInvoke;
}
/// <summary>
/// 返回消息
/// </summary>
/// <param name="moduleConfig"></param>
/// <param name="context"></param>
/// <param name="data"></param>
/// <returns></returns>
public async Task RepliedAsync(WebSocketModuleConfig moduleConfig,
WebSocketHandleContext context,
object data)
{
if (moduleConfig.IsResponseUseReturn)
{
var responseContent = JsonHelper.Serialize(data);
await context.SendAsync(responseContent);
}
else
{
IJsonToken jsonData;
jsonData = JsonHelper.Object(obj =>
{
obj[moduleConfig.MsgIdJsonKey] = context.MsgId;
obj[moduleConfig.ThemeJsonKey] = context.MsgTheme;
obj[moduleConfig.DataJsonKey] = data is null ? null : JsonHelper.FromObject(data);
});
var msg = jsonData.ToString();
await context.SendAsync(msg);
}
}
}

2
Serein.Proto.WebSocket/Handle/WebSocketHandleConfiguration.cs → Serein.Proto.WebSocket/Handle/WebSocketMethodConfig.cs
View File

@@ -1,6 +1,6 @@
namespace Serein.Proto.WebSocket.Handle
{
internal class WebSocketHandleConfiguration : HandleConfiguration
public class WebSocketMethodConfig : MethodInvokeConfiguration
{
/// <summary>
/// 主题

5
Serein.Proto.WebSocket/Handle/WebSocketHandleModuleConfig.cs → Serein.Proto.WebSocket/Handle/WebSocketModuleConfig.cs
View File

@@ -3,20 +3,23 @@
/// <summary>
/// 远程环境配置
/// </summary>
public class WebSocketHandleModuleConfig
public class WebSocketModuleConfig
{
/// <summary>
/// 有关消息ID的 Json Key
/// </summary>
public string MsgIdJsonKey { get; set; } = string.Empty;
/// <summary>
/// 有关消息主题的 Json Key
/// </summary>
public string ThemeJsonKey { get; set; } = string.Empty;
/// <summary>
/// 有关数据的 Json Key
/// </summary>
public string DataJsonKey { get; set; } = string.Empty;
/// <summary>
/// 使用怎么样的数据
/// </summary>

39
Serein.Proto.WebSocket/Handle/WebSocketMsgHandleHelper.cs
View File

@@ -3,6 +3,7 @@ using Serein.Proto.WebSocket.Attributes;
using System.Collections.Concurrent;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Threading.Tasks;
namespace Serein.Proto.WebSocket.Handle
{
@@ -27,7 +28,7 @@ namespace Serein.Proto.WebSocket.Handle
/// </summary>
/// <param name="moduleConfig">模块配置</param>
/// <returns></returns>
private WebSocketHandleModule AddMyHandleModule(WebSocketHandleModuleConfig moduleConfig)
private WebSocketHandleModule AddMsgHandleModule(WebSocketHandleModuleConfig moduleConfig)
{
var key = (moduleConfig.ThemeJsonKey, moduleConfig.DataJsonKey);
if (!MyHandleModuleDict.TryGetValue(key, out var myHandleModule))
@@ -45,7 +46,7 @@ namespace Serein.Proto.WebSocket.Handle
public void RemoveModule(ISocketHandleModule socketControlBase)
{
var type = socketControlBase.GetType();
var moduleAttribute = type.GetCustomAttribute<AutoSocketModuleAttribute>();
var moduleAttribute = type.GetCustomAttribute<WebSocketModuleAttribute>();
if (moduleAttribute is null)
{
return;
@@ -71,7 +72,7 @@ namespace Serein.Proto.WebSocket.Handle
where T : ISocketHandleModule
{
var type = typeof(T);
var moduleAttribute = type.GetCustomAttribute<AutoSocketModuleAttribute>();
var moduleAttribute = type.GetCustomAttribute<WebSocketModuleAttribute>();
if (moduleAttribute is null)
{
return;
@@ -89,11 +90,11 @@ namespace Serein.Proto.WebSocket.Handle
IsResponseUseReturn = isResponseUseReturn,
};
var handleModule = AddMyHandleModule(moduleConfig);
var handleModule = AddMsgHandleModule(moduleConfig);
var configs = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Select<MethodInfo, WebSocketHandleConfiguration?>(methodInfo =>
.Select<MethodInfo, WebSocketMethodHandleConfig?>(methodInfo =>
{
var methodsAttribute = methodInfo.GetCustomAttribute<AutoSocketHandleAttribute>();
var methodsAttribute = methodInfo.GetCustomAttribute<WsMethodAttribute>();
if (methodsAttribute is null)
{
return default;
@@ -105,8 +106,7 @@ namespace Serein.Proto.WebSocket.Handle
methodsAttribute.ThemeValue = methodInfo.Name;
}
#region 生成处理配置
var config = new WebSocketHandleConfiguration();
var config = new WebSocketMethodHandleConfig();
config.ThemeValue = methodsAttribute.ThemeValue;
config.ArgNotNull = methodsAttribute.ArgNotNull;
@@ -142,24 +142,7 @@ namespace Serein.Proto.WebSocket.Handle
config.IsCheckArgNotNull = parameterInfos.Select(p => p.GetCustomAttribute<NotNullAttribute>() != null).ToArray(); // 是否检查null
#endif
if (config.IsCheckArgNotNull is null)
{
config.IsCheckArgNotNull = parameterInfos.Select(p => p.GetCustomAttribute<NeedfulAttribute>() != null).ToArray(); // 是否检查null
}
else
{
// 兼容两种非空特性的写法
var argNotNull = parameterInfos.Select(p => p.GetCustomAttribute<NeedfulAttribute>() != null).ToArray(); // 是否检查null
for (int i = 0; i < config.IsCheckArgNotNull.Length; i++)
{
if (!config.IsCheckArgNotNull[i] && argNotNull[i])
{
config.IsCheckArgNotNull[i] = true;
}
}
}
#endregion
var value = methodsAttribute.ThemeValue;
@@ -189,7 +172,7 @@ namespace Serein.Proto.WebSocket.Handle
/// </summary>
/// <param name="context">此次请求的上下文</param>
/// <returns></returns>
public void Handle(WebSocketMsgContext context)
public async Task HandleAsync(WebSocketMsgContext context)
{
foreach (var module in MyHandleModuleDict.Values)
{
@@ -197,7 +180,7 @@ namespace Serein.Proto.WebSocket.Handle
{
return;
}
_ = module.HandleAsync(context);
await module.HandleAsync(context);
}

55
Serein.Proto.WebSocket/ISereinWebSocketService.cs Normal file
View File

@@ -0,0 +1,55 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using NetWebSocket = System.Net.WebSockets.WebSocket;
namespace Serein.Proto.WebSocket
{
/// <summary>
/// WebSocket服务
/// </summary>
public interface ISereinWebSocketService
{
/// <summary>
/// 目前有多少个连接
/// </summary>
int ConcetionCount { get; }
/// <summary>
/// 添加处理模块
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
ISereinWebSocketService AddHandleModule<T>() where T : ISocketHandleModule, new();
/// <summary>
/// 添加处理模块
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instanceFactory">使用指定的实例</param>
/// <returns></returns>
ISereinWebSocketService AddHandleModule<T>(Func<ISocketHandleModule> instanceFactory) where T : ISocketHandleModule;
/// <summary>
/// 跟踪未处理的异常
/// </summary>
/// <param name="onExceptionTrackingAsync"></param>
/// <returns></returns>
ISereinWebSocketService TrackUnhandledExceptions(Func<Exception, Func<object, Task>, Task> onExceptionTrackingAsync);
/// <summary>
/// 添加新的 WebSocket 连接进行处理消息
/// </summary>
/// <param name="webSocket"></param>
Task AddWebSocketHandleAsync(NetWebSocket webSocket);
/// <summary>
/// 推送消息
/// </summary>
/// <param name="latestData"></param>
/// <returns></returns>
Task PushDataAsync(object latestData);
}
}

5
Serein.Proto.WebSocket/ISocketHandleModule.cs
View File

@@ -1,10 +1,7 @@
using System;
namespace Serein.Proto.WebSocket
namespace Serein.Proto.WebSocket
{
public interface ISocketHandleModule
{
}
}

30
Serein.Proto.WebSocket/SendType.cs Normal file
View File

@@ -0,0 +1,30 @@
namespace Serein.Proto.WebSocket
{
public partial class SereinWebSocketService
{
public enum SendType
{
/// <summary>
/// 不发送数据
/// </summary>
None,
/// <summary>
/// 发送字符串
/// </summary>
String,
/// <summary>
/// 发送对象
/// </summary>
Object,
/// <summary>
/// 异步发送字符串
/// </summary>
StringAsync,
/// <summary>
/// 异步发送对象
/// </summary>
ObjectAsync
}
}
}

12
Serein.Proto.WebSocket/Serein.Proto.WebSocket.csproj
View File

@@ -1,7 +1,7 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net8.0;net462</TargetFrameworks>
<TargetFrameworks>net8.0;</TargetFrameworks>
<ImplicitUsings>enable</ImplicitUsings>
<LangVersion>latest</LangVersion>
<Nullable>enable</Nullable>
@@ -16,8 +16,18 @@
</PropertyGroup>
<ItemGroup>
<Compile Remove="Handle\WebSocketMsgHandleHelper.cs" />
<Compile Remove="WebSocketClient.cs" />
<Compile Remove="WebSocketServer.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Library\Serein.Library.csproj" />
</ItemGroup>
<ItemGroup>
<Folder Include="Models\" />
</ItemGroup>
</Project>

400
Serein.Proto.WebSocket/SereinWebSocketService.cs Normal file
View File

@@ -0,0 +1,400 @@
using Serein.Library;
using Serein.Library.Utils;
using Serein.Proto.WebSocket.Attributes;
using Serein.Proto.WebSocket.Handle;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net.Sockets;
using System.Net.WebSockets;
using System.Reactive;
using System.Reflection;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using NetWebSocket = System.Net.WebSockets.WebSocket;
namespace Serein.Proto.WebSocket
{
/// <summary>
/// WebSocket 服务类，负责管理所有 WebSocket 连接和处理模块
/// </summary>
public partial class SereinWebSocketService : ISereinWebSocketService
{
/// <summary>
/// (Theme Name ,Data Name) - HandleModule
/// </summary>
private readonly ConcurrentDictionary<(string, string), WebSocketHandleModule> _socketModules;
/// <summary>
/// 追踪未处理的异常
/// </summary>
private Func<Exception, Func<object, Task>, Task> _onExceptionTrackingAsync;
/// <summary>
/// 维护所有 WebSocket 连接
/// </summary>
private readonly List<NetWebSocket> _sockets;
/// <summary>
/// 用于增加、移除 WebSocket 连接时，保证线程安全操作
/// </summary>
private readonly object _lock = new object();
public int ConcetionCount => _sockets.Count;
public SereinWebSocketService()
{
_socketModules = new ConcurrentDictionary<(string, string), WebSocketHandleModule>();
_sockets = new List<NetWebSocket>();
_lock = new object();
}
#region 添加处理模块
/// <summary>
/// 添加处理模块，使用指定的实例工厂和异常追踪回调
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instanceFactory"></param>
/// <param name="onExceptionTracking"></param>
public ISereinWebSocketService AddHandleModule<T>() where T : ISocketHandleModule, new()
{
var type = typeof(T);
Func<ISocketHandleModule> instanceFactory = () => (T)Activator.CreateInstance(type);
return AddHandleModule(type, instanceFactory);
}
/// <summary>
/// 添加处理模块，使用指定的实例工厂和异常追踪回调
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instanceFactory"></param>
/// <param name="onExceptionTracking"></param>
public ISereinWebSocketService AddHandleModule<T>(Func<ISocketHandleModule> instanceFactory) where T : ISocketHandleModule
{
var type = typeof(T);
return AddHandleModule(type, instanceFactory);
}
/// <summary>
/// 添加处理模块，使用指定的类型、实例工厂和异常追踪回调
/// </summary>
/// <param name="type"></param>
/// <param name="instanceFactory"></param>
/// <param name="onExceptionTracking"></param>
private ISereinWebSocketService AddHandleModule(Type type, Func<ISocketHandleModule> instanceFactory)
{
if(!CheckAttribute<WebSocketModuleAttribute>(type, out var attribute))
{
throw new Exception($"类型 {type} 需要标记 WebSocketModuleAttribute 特性");
}
var modbuleConfig = GetConfig(attribute);
var module = GetOrAddModule(modbuleConfig);
var methodInfos = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).ToArray();
var methodConfigs = CreateMethodConfig(methodInfos, instanceFactory);
SereinEnv.WriteLine(InfoType.INFO, $"add websocket handle model :");
SereinEnv.WriteLine(InfoType.INFO, $"theme key, data key : {modbuleConfig.ThemeJsonKey}, {modbuleConfig.DataJsonKey}");
foreach (var methodConfig in methodConfigs)
{
SereinEnv.WriteLine(InfoType.INFO, $"theme value : {methodConfig!.ThemeValue} ");
var result = module.AddHandleConfigs(methodConfig);
}
return this;
}
/// <summary>
/// 检查特性
/// </summary>
/// <typeparam name="TAttribute"></typeparam>
/// <param name="type"></param>
/// <param name="attribute"></param>
/// <returns></returns>
private bool CheckAttribute<TAttribute>(Type type, out TAttribute attribute) where TAttribute : Attribute
{
attribute = type.GetCustomAttribute<TAttribute>();
if (attribute is null)
{
return false;
}
return true;
}
/// <summary>
/// 获取模块配置
/// </summary>
/// <param name="moduleAttribute"></param>
/// <returns></returns>
private WebSocketModuleConfig GetConfig(WebSocketModuleAttribute moduleAttribute)
{
var themeKey = moduleAttribute.ThemeKey;
var dataKey = moduleAttribute.DataKey;
var msgIdKey = moduleAttribute.MsgIdKey;
var isResponseUseReturn = moduleAttribute.IsResponseUseReturn;
var moduleConfig = new WebSocketModuleConfig()
{
ThemeJsonKey = themeKey,
DataJsonKey = dataKey,
MsgIdJsonKey = msgIdKey,
IsResponseUseReturn = isResponseUseReturn,
};
return moduleConfig;
}
/// <summary>
/// 获取或添加消息处理与异常处理
/// </summary>
/// <param name="moduleConfig">模块配置</param>
/// <returns></returns>
private WebSocketHandleModule GetOrAddModule(WebSocketModuleConfig moduleConfig)
{
var key = (moduleConfig.ThemeJsonKey, moduleConfig.DataJsonKey);
if (_socketModules.TryGetValue(key, out var wsHandleModule))
{
return wsHandleModule;
}
wsHandleModule = new WebSocketHandleModule(moduleConfig);
_socketModules[key] = wsHandleModule;
return wsHandleModule;
}
/// <summary>
/// 创建方法配置
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instanceFactory"></param>
/// <param name="onExceptionTracking"></param>
/// <returns></returns>
private List<WebSocketMethodConfig> CreateMethodConfig(MethodInfo[] methodInfos, Func<ISocketHandleModule> instanceFactory)
{
List<WebSocketMethodConfig> configs = [];
foreach (var methodInfo in methodInfos)
{
var wsMethodAttribute = methodInfo.GetCustomAttribute<WsMethodAttribute>();
if (wsMethodAttribute is null)
{
continue;
}
var parameterInfos = methodInfo.GetParameters();
var temp_array = parameterInfos.Select(p =>
{
var isSend = CheckSendType(p.ParameterType, out var sendType);
return new
{
IsNeedSend = isSend,
Type = sendType
};
}).ToArray();
var config = new WebSocketMethodConfig
{
ThemeValue = string.IsNullOrEmpty(wsMethodAttribute.ThemeValue) ? methodInfo.Name : wsMethodAttribute.ThemeValue,
IsReturnValue = wsMethodAttribute.IsReturnValue,
DelegateDetails = new DelegateDetails(methodInfo), // 对应theme的emit构造委托调用工具类
InstanceFactory = instanceFactory, // 调用emit委托时的实例
//OnExceptionTracking = onExceptionTracking, // 异常追踪
ParameterType = parameterInfos.Select(t => t.ParameterType).ToArray(), // 入参参数类型
ParameterName = parameterInfos.Select(t => $"{t.Name}").ToArray(), // 入参参数名称
UseRequest = parameterInfos.Select(p => p.GetCustomAttribute<UseRequestAttribute>() is not null).ToArray(),// 是否使用整体data数据
UseData = parameterInfos.Select(p => p.GetCustomAttribute<UseDataAttribute>() is not null).ToArray(), // 是否使用整体data数据
UseMsgId = parameterInfos.Select(p => p.GetCustomAttribute<UseMsgIdAttribute>() is not null).ToArray(), // 是否使用消息ID
IsNeedSendDelegate = temp_array.Select(p => p.IsNeedSend).ToArray(), // 是否需要发送消息的委托
SendDelegateType = temp_array.Select(p => p.Type).ToArray(), // 发送消息的委托类型
CachedSendDelegates = new Delegate[temp_array.Length], // 提前缓存发送委托数组
};
configs.Add(config);
}
return configs;
}
private bool CheckSendType(Type type , out SendType sendType)
{
if (type.IsAssignableFrom(typeof(Func<object, Task>)))
{
sendType = SendType.ObjectAsync;
}
else if (type.IsAssignableFrom(typeof(Func<string, Task>)))
{
sendType = SendType.StringAsync;
}
else if (type.IsAssignableFrom(typeof(Action<object>)))
{
sendType = SendType.StringAsync;
}
else if (type.IsAssignableFrom(typeof(Action<string>)))
{
sendType = SendType.StringAsync;
}
else
{
sendType = SendType.None;
return false;
}
return true;
}
#endregion
/// <summary>
/// 跟踪未处理的异常
/// </summary>
/// <returns></returns>
public ISereinWebSocketService TrackUnhandledExceptions(Func<Exception, Func<object, Task>, Task> onExceptionTrackingAsync)
{
_onExceptionTrackingAsync = onExceptionTrackingAsync;
return this;
}
/// <summary>
/// 传入新的 WebSocket 连接，开始进行处理
/// </summary>
/// <param name="webSocket"></param>
/// <summary>
/// 处理新的 WebSocket 连接
/// </summary>
/// <param name="socket"></param>
/// <returns></returns>
public async Task AddWebSocketHandleAsync(NetWebSocket socket)
{
lock (_lock) { _sockets.Add(socket); }
var buffer = new byte[4096];
var msgHandleUtil = new WebSocketMessageTransmissionTool(); // 消息队列
_ = Task.Run(async () =>
{
await HandleMsgAsync(socket, msgHandleUtil);
});
try
{
while (socket.State == WebSocketState.Open)
{
var result = await socket.ReceiveAsync(buffer: new ArraySegment<byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
break;
}
else if (result.MessageType == WebSocketMessageType.Text)
{
var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
Console.WriteLine($"收到客户端消息: {message}");
var echo = Encoding.UTF8.GetBytes(message);
await msgHandleUtil.WriteMsgAsync(message); // 异步传递消息
}
}
}
catch (Exception ex)
{
Console.WriteLine($"WebSocket 异常: {ex.Message}");
}
finally
{
lock (_lock) { _sockets.Remove(socket); }
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "关闭连接", CancellationToken.None);
socket.Dispose();
}
}
/// <summary>
/// 处理消息
/// </summary>
/// <param name="webSocket"></param>
/// <param name="tranTool"></param>
/// <returns></returns>
private async Task HandleMsgAsync(NetWebSocket webSocket,WebSocketMessageTransmissionTool tranTool)
{
//var AuthorizedClients = new ConcurrentDictionary<string, WebSocketAuthorizedHelper>();
async Task sendasync(string text)
{
await SocketExtension.SendAsync(webSocket, text); // 回复客户端，处理方法中入参如果需要发送消息委托，则将该回调方法作为委托参数传入
}
/*
ObjectPool<WebSocketMsgContext> contextPool = new ObjectPool<WebSocketMsgContext>(() =>
{
return new WebSocketMsgContext(sendasync);
}, 20);
var context = contextPool.Allocate();
contextPool.Free(context);
*/
while (webSocket.State == WebSocketState.Open)
{
var message = await tranTool.WaitMsgAsync(); // 有消息时通知
var context = new WebSocketHandleContext(sendasync);
context.MsgRequest = JsonHelper.Parse(message);
context.OnExceptionTrackingAsync = _onExceptionTrackingAsync;
await HandleAsync(context); // 处理消息
}
}
/// <summary>
/// 异步消息
/// </summary>
/// <param name="context">此次请求的上下文</param>
/// <returns></returns>
private async Task HandleAsync(WebSocketHandleContext context)
{
foreach (var module in _socketModules.Values)
{
if (context.Handle)
{
return;
}
await module.HandleAsync(context);
}
}
/// <summary>
/// 给所有客户端广播最新数据
/// </summary>
/// <param name="latestData"></param>
/// <returns></returns>
public async Task PushDataAsync(object latestData)
{
var options = new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
var json = JsonSerializer.Serialize(latestData, options);
var buffer = Encoding.UTF8.GetBytes(json);
var segment = new ArraySegment<byte>(buffer);
List<NetWebSocket> socketsCopy;
lock (_lock)
{
socketsCopy = _sockets.ToList();
}
foreach (var socket in socketsCopy)
{
if (socket.State == WebSocketState.Open)
{
try
{
await socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None);
}
catch
{
// 忽略异常或移除失效连接
}
}
}
}
}
}

29
Serein.Proto.WebSocket/SocketExtension.cs Normal file
View File

@@ -0,0 +1,29 @@
using Serein.Library.Utils;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using NetWebSocket = System.Net.WebSockets.WebSocket;
namespace Serein.Proto.WebSocket
{
public class SocketExtension
{
/// <summary>
/// 发送消息
/// </summary>
/// <param name="webSocket"></param>
/// <param name="message"></param>
/// <returns></returns>
public static async Task SendAsync(NetWebSocket webSocket, string message)
{
var buffer = Encoding.UTF8.GetBytes(message);
await webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}

37
Serein.Proto.WebSocket/TestClass.cs Normal file
View File

@@ -0,0 +1,37 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.Proto.WebSocket
{
public class ClassA : ISocketHandleModule
{
}
public class ClassB : ISocketHandleModule
{
}
public class ClassC : ISocketHandleModule
{
}
internal class TestClass
{
public void Run()
{
SereinWebSocketService sereinWebSocketService = new SereinWebSocketService();
sereinWebSocketService.AddHandleModule<ClassA>();
sereinWebSocketService.AddHandleModule<ClassB>(() => new ClassB());
sereinWebSocketService.TrackUnhandledExceptions(OnExceptionTrackingAsync);
}
private static async Task OnExceptionTrackingAsync(Exception ex, Func<object, Task> SendAsync)
{
await SendAsync("");
}
}
}

100
Serein.Proto.WebSocket/WebSocketClient.cs
View File

@@ -6,6 +6,7 @@ using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using NetWebSocket = System.Net.WebSockets.WebSocket;
namespace Serein.Proto.WebSocket
{
@@ -50,6 +51,7 @@ namespace Serein.Proto.WebSocket
}
}
/// <summary>
/// 发送消息
/// </summary>
@@ -67,7 +69,7 @@ namespace Serein.Proto.WebSocket
private async Task ReceiveAsync()
{
var msgQueueUtil = new MsgHandleUtil();
var msgQueueUtil = new WebSocketMessageTransmissionTool();
_ = Task.Run(async () =>
{
await HandleMsgAsync(_client, msgQueueUtil);
@@ -100,12 +102,6 @@ namespace Serein.Proto.WebSocket
{
await _client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
}
//else
//{
// var completeMessage = receivedMessage.ToString();
// MsgHandleHelper.HandleMsg(SendAsync, completeMessage); // 处理消息，如果方法入参是需要发送消息委托时，将 SendAsync 作为委托参数提供
// //Debug.WriteLine($"Received: {completeMessage}");
//}
}
@@ -116,8 +112,13 @@ namespace Serein.Proto.WebSocket
}
}
public async Task HandleMsgAsync(System.Net.WebSockets.WebSocket webSocket, MsgHandleUtil msgQueueUtil)
/// <summary>
/// 处理消息
/// </summary>
/// <param name="webSocket"></param>
/// <param name="msgQueueUtil"></param>
/// <returns></returns>
public async Task HandleMsgAsync(NetWebSocket webSocket, WebSocketMessageTransmissionTool msgQueueUtil)
{
async Task sendasync(string text)
{
@@ -128,87 +129,8 @@ namespace Serein.Proto.WebSocket
var message = await msgQueueUtil.WaitMsgAsync(); // 有消息时通知
var context = new WebSocketMsgContext(sendasync);
context.MsgRequest = JsonHelper.Parse(message);
MsgHandleHelper.Handle(context); // 处理消息
//using (var context = new WebSocketMsgContext(sendasync))
//{
// context.JsonObject = JObject.Parse(message);
// await MsgHandleHelper.HandleAsync(context); // 处理消息
//}
//_ = Task.Run(() => {
// JObject json = JObject.Parse(message);
// WebSocketMsgContext context = new WebSocketMsgContext(async (text) =>
// {
// await SocketExtension.SendAsync(webSocket, text); // 回复客户端，处理方法中入参如果需要发送消息委托，则将该回调方法作为委托参数传入
// });
// context.JsonObject = json;
// await MsgHandleHelper.HandleAsync(context); // 处理消息
//});
MsgHandleHelper.HandleAsync(context); // 处理消息
}
/* #region 消息处理
private readonly string ThemeField;
private readonly ConcurrentDictionary<string, HandldConfig> ThemeConfigs = new ConcurrentDictionary<string, HandldConfig>();
public async Task HandleSocketMsg(string jsonStr)
{
JObject json;
try
{
json = JObject.Parse(jsonStr);
}
catch (Exception ex)
{
await SendAsync(_client, ex.Message);
return;
}
// 获取到消息
string themeName = json[ThemeField]?.ToString();
if (!ThemeConfigs.TryGetValue(themeName, out var handldConfig))
{
return;
}
object dataValue;
if (string.IsNullOrEmpty(handldConfig.DataField))
{
dataValue = json.ToObject(handldConfig.DataType);
}
else
{
dataValue = json[handldConfig.DataField].ToObject(handldConfig.DataType);
}
await handldConfig.Invoke(dataValue, SendAsync);
}
public void AddConfig(string themeName, Type dataType, MsgHandler msgHandler)
{
if (!ThemeConfigs.TryGetValue(themeName, out var handldConfig))
{
handldConfig = new HandldConfig
{
DataField = themeName,
DataType = dataType
};
ThemeConfigs.TryAdd(themeName, handldConfig);
}
handldConfig.HandldAsync += msgHandler;
}
public void RemoteConfig(string themeName, MsgHandler msgHandler)
{
if (ThemeConfigs.TryGetValue(themeName, out var handldConfig))
{
handldConfig.HandldAsync -= msgHandler;
if (!handldConfig.HasSubscribers)
{
ThemeConfigs.TryRemove(themeName, out _);
}
}
}
#endregion*/
}
}
}

82
Serein.Proto.WebSocket/Handle/WebSocketMsgContext.cs → Serein.Proto.WebSocket/WebSocketHandleContext.cs
View File

@@ -1,21 +1,29 @@
using Serein.Library.Api;
using Serein.Library.Utils;
using Serein.Proto.WebSocket.Handle;
using System;
using System.Threading.Tasks;
namespace Serein.Proto.WebSocket.Handle
namespace Serein.Proto.WebSocket
{
/// <summary>
/// 消息处理上下文
/// </summary>
public class WebSocketMsgContext : IDisposable
public class WebSocketHandleContext : IDisposable
{
public WebSocketMsgContext(Func<string, Task> sendAsync)
/// <summary>
/// 构造函数，传入发送消息的异步方法
/// </summary>
/// <param name="sendAsync"></param>
public WebSocketHandleContext(Func<string, Task> sendAsync)
{
_sendAsync = sendAsync;
}
/// <summary>
/// 释放资源，清理消息上下文
/// </summary>
public void Dispose()
{
MsgRequest = null;
@@ -23,7 +31,6 @@ namespace Serein.Proto.WebSocket.Handle
MsgId = string.Empty;
MsgData = null;
MsgData = null;
_sendAsync = null;
}
/// <summary>
@@ -37,7 +44,8 @@ namespace Serein.Proto.WebSocket.Handle
}
} }
public bool _handle = false;
private bool _handle = false;
/// <summary>
/// 消息本体（IJsonToken）
@@ -59,8 +67,16 @@ namespace Serein.Proto.WebSocket.Handle
/// </summary>
public IJsonToken? MsgData { get; set; }
/// <summary>
/// 异常外部感知使能
/// </summary>
public Func<Exception, Func<object, Task>, Task> OnExceptionTrackingAsync { get; set; }
private Func<string, Task>? _sendAsync;
/// <summary>
/// 发送消息
/// </summary>
private Func<string, Task> _sendAsync;
/// <summary>
/// 发送消息
@@ -69,48 +85,40 @@ namespace Serein.Proto.WebSocket.Handle
/// <returns></returns>
public async Task SendAsync(string msg)
{
if (_sendAsync is null) return;
await _sendAsync.Invoke(msg);
}
/// <summary>
/// 返回消息
/// 触发异常追踪
/// </summary>
/// <param name="moduleConfig"></param>
/// <param name="context"></param>
/// <param name="data"></param>
/// <returns></returns>
public async Task RepliedAsync(WebSocketHandleModuleConfig moduleConfig,
WebSocketMsgContext context,
object data)
public void TriggerExceptionTracking(string exMessage)
{
if (moduleConfig.IsResponseUseReturn)
var ex = new Exception(exMessage);
Func<object, Task> func = async (data) =>
{
var responseContent = JsonHelper.Serialize(data);
await SendAsync(responseContent);
}
else
var msg = JsonHelper.Serialize(data);
await _sendAsync.Invoke(msg);
};
OnExceptionTrackingAsync.Invoke(ex, func);
}
/// <summary>
/// 触发异常追踪
/// </summary>
public void TriggerExceptionTracking(Exception ex)
{
Func<object, Task> func = async (data) =>
{
var msg = JsonHelper.Serialize(data);
await _sendAsync.Invoke(msg);
IJsonToken jsonData;
jsonData = JsonHelper.Object(obj =>
{
obj[moduleConfig.MsgIdJsonKey] = context.MsgId;
obj[moduleConfig.ThemeJsonKey] = context.MsgTheme;
obj[moduleConfig.DataJsonKey] = data is null ? null
: JsonHelper.FromObject(data);
});
var msg = jsonData.ToString();
//Console.WriteLine($"[{msgId}] => {theme}");
await SendAsync(msg);
}
};
OnExceptionTrackingAsync.Invoke(ex, func);
}
}
}

37
Serein.Proto.WebSocket/TestExtension.cs → Serein.Proto.WebSocket/WebSocketMessageTransmissionTool.cs
View File

@@ -1,28 +1,15 @@
using Serein.Library.Utils;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using System.Threading.Channels;
namespace Serein.Proto.WebSocket
{
/// <summary>
/// 消息处理工具
/// </summary>
public class MsgHandleUtil
public class WebSocketMessageTransmissionTool
{
private readonly Channel<string> _msgChannel;
/// <summary>
/// 初始化优先容器
/// </summary>
/// <param name="capacity"></param>
public MsgHandleUtil(int capacity = 100)
public WebSocketMessageTransmissionTool(int capacity = 100)
{
_msgChannel = Channel.CreateBounded<string>(new BoundedChannelOptions(capacity)
{
@@ -72,22 +59,4 @@ namespace Serein.Proto.WebSocket
_msgChannel.Writer.Complete();
}
}
public class SocketExtension
{
/// <summary>
/// 发送消息
/// </summary>
/// <param name="webSocket"></param>
/// <param name="message"></param>
/// <returns></returns>
public static async Task SendAsync(System.Net.WebSockets.WebSocket webSocket, string message)
{
var buffer = Encoding.UTF8.GetBytes(message);
await webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
}
}
}

6
Serein.Proto.WebSocket/WebSocketServer.cs
View File

@@ -189,7 +189,7 @@ namespace Serein.Proto.WebSocket
return;
}
var msgQueueUtil = new MsgHandleUtil();
var msgQueueUtil = new WebSocketMessageTransmissionTool();
_ = Task.Run(async () =>
{
await HandleMsgAsync(webSocket,msgQueueUtil, authorizedHelper);
@@ -240,7 +240,7 @@ namespace Serein.Proto.WebSocket
public async Task HandleMsgAsync(System.Net.WebSockets.WebSocket webSocket,
MsgHandleUtil msgQueueUtil,
WebSocketMessageTransmissionTool msgQueueUtil,
WebSocketAuthorizedHelper authorizedHelper)
{
async Task sendasync(string text)
@@ -265,7 +265,7 @@ namespace Serein.Proto.WebSocket
}
var context = new WebSocketMsgContext(sendasync);
context.MsgRequest = JsonHelper.Parse(message);
MsgHandleHelper.Handle(context); // 处理消息
MsgHandleHelper.HandleAsync(context); // 处理消息
//using (var context = new WebSocketMsgContext(sendasync))
//{

2
Workbench/App.xaml.cs
View File

@@ -51,7 +51,7 @@ namespace Serein.Workbench
private void Application_Startup(object sender, StartupEventArgs e)
{
#if DEBUG && true
#if DEBUG && false
try
{

12
Workbench/Test.cs Normal file
View File

@@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.Workbench
{
internal class Test
{
}
}