T2FGame.Network.Socket 1.0.6

T2FGame.Network.Socket

T2FGame 框架的网络层，基于 SuperSocket 实现高性能多协议通信，支持 TCP、UDP 和 WebSocket。

功能特性

• 多协议支持：TCP、UDP、WebSocket 三种传输协议
• 高性能服务器：基于 SuperSocket 2.x
• 自定义协议编解码：支持变长消息、心跳检测
• 会话管理：GameSession 生命周期管理
• 消息分发：与 Action 框架无缝集成
• 推送/广播：支持主动推送消息给客户端

安装

<PackageReference Include="T2FGame.Network.Socket" />

快速开始

选择传输协议

var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices((context, services) =>
    {
        // 注册 Action 框架
        services.AddT2FGameAction(typeof(UserController).Assembly);
        services.AddActionPipeline();

        // 方式1: 仅 TCP
        services.AddT2FGameSocket();

        // 方式2: 仅 UDP
        services.AddT2FGameUdp();

        // 方式3: 仅 WebSocket
        services.AddT2FGameWebSocket();

        // 方式4: TCP + WebSocket
        services.AddT2FGameDualProtocol();

        // 方式5: TCP + UDP + WebSocket (全协议)
        services.AddT2FGameAllProtocols();

        // 广播服务
        services.AddT2FGameBroadcast();
    })
    .Build();

await host.RunAsync();

配置选项 (appsettings.json)

{
  "serverOptions": {
    "name": "T2FGame TCP Server",
    "listeners": [
      { "ip": "Any", "port": 9001 }
    ]
  },
  "udpOptions": {
    "name": "T2FGame UDP Server",
    "ip": "Any",
    "port": 9002
  },
  "webSocketOptions": {
    "name": "T2FGame WebSocket Server",
    "ip": "Any",
    "port": 9010
  }
}

协议对比

协议格式

TCP/UDP 消息包结构

+------------------+------------------------+
|  Length (4字节)  |  ExternalMessage       |
+------------------+------------------------+
|     BigEndian    |    Protobuf 序列化     |
+------------------+------------------------+

WebSocket 消息包结构

+------------------------+
|  ExternalMessage       |
+------------------------+
|    Protobuf 序列化     |
+------------------------+

WebSocket 协议自带分帧机制，无需长度前缀。

ExternalMessage 结构

message ExternalMessage {
    int32 cmdCode = 1;        // 命令类型 (0=心跳, 1=业务)
    int32 protocolSwitch = 2; // 协议开关
    int32 cmdMerge = 3;       // 路由 (高16位=cmd, 低16位=subCmd)
    int32 responseStatus = 4; // 响应状态码 (0=成功)
    string validMsg = 5;      // 错误消息
    bytes data = 6;           // 业务数据
    int32 msgId = 7;          // 消息ID
    map<string, string> metadata = 8; // 扩展元数据
}

核心组件

SocketActionDispatcher（消息分发器）

三种协议共享同一个分发器：

public class SocketActionDispatcher
{
    // 处理接收到的数据包
    public async Task HandleAsync(
        string sessionId,
        GamePackage package,
        Func<byte[], ValueTask> sendCallback,
        CancellationToken cancellationToken = default);

    // 会话管理
    public GameSession GetOrCreateSession(string sessionId);
    public GameSession? GetSession(string sessionId);
    public bool RemoveSession(string sessionId);
    public int SessionCount { get; }
}

GameSession（游戏会话）

public class GameSession
{
    public string SessionId { get; }
    public long PlayerId { get; set; }
    public bool IsAuthenticated { get; }
    public DateTime LastActiveAtUtc { get; }
    public Dictionary<string, string> Metadata { get; }

    public bool SetAuthenticated(long playerId);
    public void ClearAuthentication();
    public void UpdateActiveTime();
}

GamePackageCodec（编解码器）

// 编码请求
byte[] data = GamePackageCodec.EncodeRequest<LoginRequest>(cmd, subCmd, request, msgId);

// 编码响应
byte[] data = GamePackageCodec.EncodeResponse(cmdMerge, response, msgId);

// 编码错误响应
byte[] data = GamePackageCodec.EncodeErrorResponse(cmdMerge, msgId, errorCode, errorMsg);

// 编码心跳
byte[] data = GamePackageCodec.EncodeHeartbeat(msgId);

WebSocketPackageAdapter（WebSocket 适配器）

// WebSocket 包转 GamePackage
GamePackage? package = WebSocketPackageAdapter.FromWebSocketPackage(wsPackage);

// GamePackage 转 WebSocket 数据（无长度前缀）
byte[] data = WebSocketPackageAdapter.ToWebSocketData(package);

// 编码响应（WebSocket 专用）
byte[] data = WebSocketPackageAdapter.EncodeResponse(cmdMerge, response, msgId);

广播服务

注册广播服务

services.AddT2FGameBroadcast(options =>
{
    options.Enabled = true;
});

使用广播

[ActionController(cmd: 1)]
public class ChatController
{
    [ActionMethod(subCmd: 1)]
    public async Task SendMessage(ChatMessage request, FlowContext context)
    {
        // 广播给所有人
        await context.Broadcast(ChatCmdInfo.Message, request);

        // 广播给指定用户
        await context.Broadcast(ChatCmdInfo.Message, request, targetUserId);

        // 广播给自己
        await context.BroadcastMe(ChatCmdInfo.Message, response);

        // 广播给房间
        await context.BroadcastToRoom(ChatCmdInfo.Message, request, roomId);
    }
}

SocketFlowContext

网络层的 FlowContext 实现，三种协议共用：

public class SocketFlowContext : FlowContext
{
    public override string SessionId { get; }
    public override long UserId { get; }
    public override bool IsAuthenticated { get; }
    public override int CmdMerge { get; }
    public override int MessageId { get; }

    // 设置认证状态
    public override bool SetAuthenticated(long userId);

    // 发送响应
    public override ValueTask SendAsync(IProtoMessage response);

    // 发送原始数据
    public override ValueTask SendRawAsync(byte[] data);
}

目录结构

T2FGame.Network.Socket/
├── Hosting/
│   ├── SuperSocketHostedService.cs   # TCP 服务托管
│   ├── UdpHostedService.cs           # UDP 服务托管
│   └── WebSocketHostedService.cs     # WebSocket 服务托管
├── Protocol/
│   ├── GamePackage.cs                # 数据包结构
│   ├── GamePackageCodec.cs           # TCP/UDP 编解码器
│   ├── GamePackageFilter.cs          # SuperSocket 协议过滤器
│   ├── WebSocketPackageAdapter.cs    # WebSocket 适配器
│   └── CommandType.cs                # 消息类型枚举
├── Dispatcher/
│   ├── SocketActionDispatcher.cs     # 消息分发器
│   └── SocketFlowContext.cs          # FlowContext 实现
├── Session/
│   └── GameSession.cs                # 游戏会话
├── Broadcast/
│   ├── SocketBroadcastService.cs     # 广播服务
│   ├── SocketBroadcastOrderService.cs # 顺序广播服务
│   ├── InMemorySessionManager.cs     # 内存会话管理器
│   └── InMemoryRoomManager.cs        # 内存房间管理器
└── DependencyInjection.cs            # 服务注册扩展

性能优化建议

1. 协议选择：

   • 登录、交易等重要操作使用 TCP
   • 位置同步、实时状态使用 UDP
   • Web/H5 客户端使用 WebSocket

2. 连接复用：复用 byte[] 缓冲区，减少 GC 压力

3. 异步处理：使用 ValueTask 避免不必要的 Task 分配

4. 批量广播：使用 IBroadcastOrderService 进行有序批量广播

客户端连接示例

TCP 客户端 (C#)

var client = new TcpClient();
await client.ConnectAsync("127.0.0.1", 9001);
var stream = client.GetStream();

// 发送消息
var data = GamePackageCodec.EncodeRequest(1, 1, loginRequest, msgId);
await stream.WriteAsync(data);

WebSocket 客户端 (JavaScript)

const ws = new WebSocket('ws://127.0.0.1:9010');
ws.binaryType = 'arraybuffer';

ws.onopen = () => {
    // 发送 Protobuf 编码的 ExternalMessage（无长度前缀）
    const message = ExternalMessage.encode({
        cmdCode: 1,
        cmdMerge: (1 << 16) | 1,
        data: loginRequestBytes,
        msgId: 1
    }).finish();
    ws.send(message);
};

ws.onmessage = (event) => {
    const response = ExternalMessage.decode(new Uint8Array(event.data));
    console.log('Response:', response);
};

UDP 客户端 (C#)

var client = new UdpClient();
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9002);

// 发送消息（格式与 TCP 相同）
var data = GamePackageCodec.EncodeRequest(1, 1, syncRequest, msgId);
await client.SendAsync(data, data.Length, endpoint);