feat: 增加 SocketDataConverter 标签

Author: ArgoZhang

src/BootstrapBlazor/Extensions/ITcpSocketClientExtensions.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 // Maintainer: Argo Zhang([email protected]) Website: https://www.blazor.zone
 
+using System.Reflection;
 using System.Runtime.Versioning;
 using System.Text;
 
@@ -107,4 +108,46 @@ public static void SetDataPackageAdapter<TEntity>(this ITcpSocketClient client,
             await callback(ret);
         };
     }
+
+    /// <summary>
+    /// Configures the specified <see cref="ITcpSocketClient"/> to use a custom data package adapter and callback
+    /// function.
+    /// </summary>
+    /// <remarks>This method sets up the <paramref name="client"/> to use the specified <paramref
+    /// name="adapter"/> for handling incoming data. If the <typeparamref name="TEntity"/> type is decorated with a <see
+    /// cref="SocketDataConverterAttribute"/>, the associated converter is used to transform the data before invoking
+    /// the <paramref name="callback"/>. The callback is called with the converted entity or <see langword="null"/> if
+    /// conversion fails.</remarks>
+    /// <typeparam name="TEntity">The type of entity that the data package adapter will handle.</typeparam>
+    /// <param name="client">The TCP socket client to configure.</param>
+    /// <param name="adapter">The data package adapter responsible for processing incoming data.</param>
+    /// <param name="callback">The callback function to invoke with the processed entity of type <typeparamref name="TEntity"/>.</param>
+    public static void SetDataPackageAdapter<TEntity>(this ITcpSocketClient client, IDataPackageAdapter adapter, Func<TEntity?, Task> callback)
+    {
+        // 设置 ITcpSocketClient 的回调函数
+        client.ReceivedCallBack = async buffer =>
+        {
+            // 将接收到的数据传递给 DataPackageAdapter 进行数据处理合规数据触发 ReceivedCallBack 回调
+            await adapter.HandlerAsync(buffer);
+        };
+
+        var type = typeof(TEntity);
+        var converterType = type.GetCustomAttribute<SocketDataConverterAttribute>();
+        if (converterType is { Type: not null })
+        {
+            if (Activator.CreateInstance(converterType.Type) is ISocketDataConverter<TEntity> socketDataConverter)
+            {
+                // 设置 DataPackageAdapter 的回调函数
+                adapter.ReceivedCallBack = async buffer =>
+                {
+                    TEntity? ret = default;
+                    if (socketDataConverter.TryConvertTo(buffer, out var t))
+                    {
+                        ret = t;
+                    }
+                    await callback(ret);
+                };
+            }
+        }
+    }
 }

src/BootstrapBlazor/Services/TcpSocket/DataConverter/SocketDataConverterAttribute.cs

@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License
+// See the LICENSE file in the project root for more information.
+// Maintainer: Argo Zhang([email protected]) Website: https://www.blazor.zone
+
+namespace BootstrapBlazor.Components;
+
+/// <summary>
+/// 
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public class SocketDataConverterAttribute : Attribute
+{
+    /// <summary>
+    /// Gets or sets the type of the <see cref="ISocketDataConverter{TEntity}"/>.
+    /// </summary>
+    public Type? Type { get; set; }
+}

src/BootstrapBlazor/Services/TcpSocket/DataConverter/SocketDataConverterBase.cs

@@ -3,6 +3,9 @@
 // See the LICENSE file in the project root for more information.
 // Maintainer: Argo Zhang([email protected]) Website: https://www.blazor.zone
 
+using System.Reflection;
+using System.Text;
+
 namespace BootstrapBlazor.Components;
 
 /// <summary>
@@ -18,4 +21,121 @@ public abstract class SocketDataConverterBase<TEntity> : ISocketDataConverter<TE
     /// <param name="entity"></param>
     /// <returns></returns>
     public abstract bool TryConvertTo(ReadOnlyMemory<byte> data, [NotNullWhen(true)] out TEntity? entity);
+
+    /// <summary>
+    /// 将字节数据转换为指定实体类型的实例。
+    /// </summary>
+    /// <param name="data"></param>
+    /// <param name="entity"></param>
+    protected virtual bool Parse(ReadOnlyMemory<byte> data, TEntity entity)
+    {
+        // 使用 SocketDataFieldAttribute 特性获取数据转换规则
+        var ret = false;
+        if (entity != null)
+        {
+            var properties = entity.GetType().GetProperties()
+                .Where(p => p.GetCustomAttribute(typeof(SocketDataFieldAttribute), false) != null && p.CanWrite).ToList();
+            foreach (var p in properties)
+            {
+                var attr = p.GetCustomAttribute<SocketDataFieldAttribute>(false);
+                if (attr != null)
+                {
+                    var type = attr.Type;
+                    if (type == null)
+                    {
+                        continue;
+                    }
+
+                    var encodingName = attr.EncodingName;
+                    var start = attr.Start;
+                    var length = attr.Length;
+
+                    if (data.Length >= start + length)
+                    {
+                        var buffer = data.Slice(start, length);
+                        p.SetValue(entity, ParseValue(buffer, type, encodingName));
+                    }
+                }
+            }
+            ret = true;
+        }
+        return ret;
+    }
+
+    /// <summary>
+    /// 将字节缓冲区转换为指定类型的值。
+    /// </summary>
+    /// <param name="buffer"></param>
+    /// <param name="type"></param>
+    /// <param name="encodingName"></param>
+    /// <returns></returns>
+    protected virtual object? ParseValue(ReadOnlyMemory<byte> buffer, Type type, string? encodingName)
+    {
+        // 根据类型转换数据
+        if (type == typeof(string))
+        {
+            var encoding = string.IsNullOrEmpty(encodingName) ? Encoding.UTF8 : Encoding.GetEncoding(encodingName);
+            return encoding.GetString(buffer.Span);
+        }
+        else if (type == typeof(int))
+        {
+            return BitConverter.ToInt32(buffer.Span);
+        }
+        else if (type == typeof(long))
+        {
+            return BitConverter.ToInt64(buffer.Span);
+        }
+        else if (type == typeof(double))
+        {
+            return BitConverter.ToDouble(buffer.Span);
+        }
+        else if (type == typeof(byte[]))
+        {
+            return buffer.ToArray();
+        }
+        if (type.IsEnum)
+        {
+            return Enum.ToObject(type, BitConverter.ToInt32(buffer.Span));
+        }
+        else if (type == typeof(bool))
+        {
+            return BitConverter.ToBoolean(buffer.Span);
+        }
+        else if (type == typeof(float))
+        {
+            return BitConverter.ToSingle(buffer.Span);
+        }
+        else if (type == typeof(short))
+        {
+            return BitConverter.ToInt16(buffer.Span);
+        }
+        else if (type == typeof(ushort))
+        {
+            return BitConverter.ToUInt16(buffer.Span);
+        }
+        else if (type == typeof(uint))
+        {
+            return BitConverter.ToUInt32(buffer.Span);
+        }
+        else if (type == typeof(ulong))
+        {
+            return BitConverter.ToUInt64(buffer.Span);
+        }
+        else
+        {
+            return ParseValueResolve(buffer, type, encodingName);
+        }
+    }
+
+    /// <summary>
+    /// 将字节缓冲区转换为指定类型的值，允许子类自定义补充解析逻辑。
+    /// </summary>
+    /// <param name="buffer"></param>
+    /// <param name="type"></param>
+    /// <param name="encodingName"></param>
+    /// <returns></returns>
+    protected virtual object? ParseValueResolve(ReadOnlyMemory<byte> buffer, Type type, string? encodingName)
+    {
+        return null;
+    }
 }

src/BootstrapBlazor/Services/TcpSocket/DataConverter/SocketDataFieldAttribute.cs

@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License
+// See the LICENSE file in the project root for more information.
+// Maintainer: Argo Zhang([email protected]) Website: https://www.blazor.zone
+
+namespace BootstrapBlazor.Components;
+
+/// <summary>
+/// Represents an attribute used to mark a field as a socket data field.
+/// </summary>
+/// <remarks>This attribute can be applied to fields to indicate that they are part of the data transmitted over a
+/// socket connection. It is intended for use in scenarios where socket communication requires specific fields to be
+/// identified for processing.</remarks>
+[AttributeUsage(AttributeTargets.Property)]
+public class SocketDataFieldAttribute : Attribute
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public Type? Type { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int Start { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int Length { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? EncodingName { get; set; }
+}