test(sdk/csharp)+fix: TCPTransport 并发写帧损坏修复 + 入站/校验器缺口补测

产品修复（测试暴露的真 bug）：
- WriteFrameAsync 无写锁：header/payload/flush 三段 await 并发交错损坏
  帧——多入站 handler 并发回写时 16 并发即复现挂死。加 _writeLock
  串行化（对齐 Go MuxConn writeMu）
- ReadLoop 超大帧分支只 break 不置 _connected=false——传输层假活
- 删除死代码 HandleInboundRequestAsync（无调用方，DispatchInbound 已内联）

补测（727→752）：
- TcpTransportInboundTests：无 handler/异常 handler 回错、超大帧断连、
  零长帧跳过、无 pending 响应忽略、16 并发全应答
- JsonSchemaValidatorBranchTests：numeric/string/array/object 约束全
  分支、$ref 未解析/转义指针、enum/const/integer 形态（87.1%→97.2%）
- CoverageBoost4：FunctionHandlerBase 同步入口/RetryConfig 抖动上限/
  MainThreadDispatcher 泛型入队/DI 空守卫

Author: cuihairu

sdks/csharp/src/Croupier.Sdk.Tests/CoverageBoost4Tests.cs

@@ -0,0 +1,150 @@
+// Copyright 2025 Croupier Authors
+// Licensed under the Apache License, Version 2.0
+
+using System;
+using Croupier.Sdk;
+using Croupier.Sdk.Extensions;
+using Croupier.Sdk.Configuration;
+using Croupier.Sdk.Models;
+using Croupier.Sdk.Threading;
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Croupier.Sdk.Tests;
+
+/// <summary>
+/// 中小缺口补测：FunctionHandlerBase 同步入口 / RetryConfig 抖动与上限 /
+/// MainThreadDispatcher 泛型入队 / DI 扩展空参守卫 / InvokeOptions 回退链。
+/// </summary>
+public class CoverageBoost4Tests
+{
+    private class EchoHandler : FunctionHandlerBase
+    {
+        public override Task<string> HandleAsync(FunctionContext context, string payload)
+        {
+            return Task.FromResult("handled:" + payload);
+        }
+    }
+
+    [Fact]
+    public void FunctionHandlerBase_SyncHandle_InvokesAsync()
+    {
+        var handler = new EchoHandler();
+        var ctx = new FunctionContext
+        {
+            FunctionId = "fn.echo",
+            CallId = Guid.NewGuid().ToString(),
+            GameId = "g",
+            Env = "dev",
+        };
+        handler.Handle(ctx, "x").Should().Be("handled:x");
+    }
+
+    [Fact]
+    public void RetryConfig_JitterAndCaps_Applied()
+    {
+        var cfg = new RetryConfig
+        {
+            InitialDelayMs = 10,
+            BackoffMultiplier = 2,
+            MaxDelayMs = 15, // 触发上限截断
+            JitterFactor = 0.0,
+        };
+        // attempt 5：10*2^5=320 → 截到 15
+        cfg.DelayMs(5).Should().Be(15);
+
+        var jitter = new RetryConfig
+        {
+            InitialDelayMs = 100,
+            BackoffMultiplier = 1,
+            MaxDelayMs = 0, // 不设上限
+            JitterFactor = 0.5,
+        };
+        var d = jitter.DelayMs(1);
+        d.Should().BeInRange(50, 150);
+    }
+
+    [Fact]
+    public void MainThreadDispatcher_EnqueueGeneric_NullIgnored()
+    {
+        var dispatcher = MainThreadDispatcher.Instance;
+        dispatcher.Enqueue<int>(null!, 5); // null action 必须被忽略
+    }
+
+    [Fact]
+    public void MainThreadDispatcher_EnqueueGeneric_ProcessesData()
+    {
+        var dispatcher = MainThreadDispatcher.Instance;
+        var seen = 0;
+        dispatcher.Enqueue<int>(v => seen = v, 42);
+        for (var i = 0; i < 128 && dispatcher.ProcessQueue(1) > 0; i++)
+        {
+        }
+        seen.Should().Be(42);
+    }
+
+    [Fact]
+    public void ServiceCollectionExtensions_NullGuards_Throw()
+    {
+        var act1 = () => CroupierServiceCollectionExtensionsForTest.AddCroupierNullCheck(null!);
+        act1.Should().Throw<ArgumentNullException>();
+
+        var act2 = () => CroupierServiceCollectionExtensionsForTest.AddCroupierWithProviderNullConfigCheck(
+            new ServiceCollection(), null!);
+        act2.Should().Throw<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void AddCroupier_RegistersClient()
+    {
+        var services = new ServiceCollection();
+        services.AddCroupier(cfg =>
+        {
+            cfg.AgentAddr = "127.0.0.1:19091";
+            cfg.GameId = "g1";
+            cfg.Env = "dev";
+        });
+        using var provider = services.BuildServiceProvider();
+        provider.GetRequiredService<CroupierClient>().Should().NotBeNull();
+    }
+
+    private static class CroupierServiceCollectionExtensionsForTest
+    {
+        // 直接调用公开扩展方法并断言空守卫（不绕私有访问器）。
+        public static void AddCroupierNullCheck(IServiceCollection services)
+        {
+            ServiceCollectionExtensionsTestShim.AddCroupier(services, (Action<ClientConfig>?)null);
+        }
+
+        public static void AddCroupierWithProviderNullConfigCheck(
+            IServiceCollection services, ICroupierConfigProvider provider)
+        {
+            ServiceCollectionExtensionsTestShim.AddCroupier(services, provider);
+        }
+    }
+}
+
+internal static class ServiceCollectionExtensionsTestShim
+{
+    public static void AddCroupier(IServiceCollection services, Action<ClientConfig>? configAction)
+        => services.AddCroupier(configAction);
+
+    public static void AddCroupier(IServiceCollection services, ICroupierConfigProvider provider)
+        => services.AddCroupier(provider);
+}
+
+internal static class MainThreadDispatcherTestExtensions
+{
+    public static void ProcessQueueAllForTest(this MainThreadDispatcher dispatcher)
+    {
+        // 处理全部已入队回调（队列容量内）。
+        for (var i = 0; i < 128; i++)
+        {
+            if (dispatcher.ProcessQueue(1) == 0)
+            {
+                break;
+            }
+        }
+    }
+}

sdks/csharp/src/Croupier.Sdk.Tests/JsonSchemaValidatorBranchTests.cs

@@ -0,0 +1,165 @@
+// Copyright 2025 Croupier Authors
+// Licensed under the Apache License, Version 2.0
+
+using System.Text.Json;
+using Croupier.Sdk.Validation;
+using FluentAssertions;
+using Xunit;
+
+namespace Croupier.Sdk.Tests;
+
+/// <summary>
+/// JsonSchemaValidator 字符串入口与各约束分支的缺口补测
+/// （numeric/string/array/object 约束、$ref 解析失败、错误消息文案）。
+/// </summary>
+public class JsonSchemaValidatorBranchTests
+{
+    private static JsonElement Parse(string json)
+    {
+        using var doc = JsonDocument.Parse(json);
+        return doc.RootElement.Clone();
+    }
+
+    [Fact]
+    public void Validate_StringEntry_MissingRequired_ReportsPath()
+    {
+        var schema = """{"type":"object","required":["name"],"properties":{"name":{"type":"string"}}}""";
+        var errors = JsonSchemaValidator.Validate("{}", schema);
+        errors.Should().NotBeEmpty();
+        errors[0].Should().Contain("name");
+    }
+
+    [Fact]
+    public void Numeric_Bounds_AllBranches()
+    {
+        var schema = """
+            {
+                "type": "number",
+                "minimum": 1,
+                "maximum": 10,
+                "exclusiveMinimum": 0.5,
+                "exclusiveMaximum": 9.5,
+                "multipleOf": 3
+            }
+            """;
+        JsonSchemaValidator.Validate("0", schema)[0].Should().Contain("less than minimum");
+        JsonSchemaValidator.Validate("11", schema)[0].Should().Contain("greater than maximum");
+        JsonSchemaValidator.Validate("0.4", schema).Should().Contain(e => e.Contains("greater than 0.5") || e.Contains("exclusiveMinimum"));
+        JsonSchemaValidator.Validate("9.5", schema).Should().Contain(e => e.Contains("less than 9.5"));
+        JsonSchemaValidator.Validate("4", schema).Should().Contain(e => e.Contains("multiple of"));
+        JsonSchemaValidator.Validate("6", schema).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void String_Constraints_AllBranches()
+    {
+        var schema = """
+            { "type": "string", "minLength": 2, "maxLength": 5, "pattern": "^[a-z]+$" }
+            """;
+        JsonSchemaValidator.Validate("\"a\"", schema)[0].Should().Contain("minLength");
+        JsonSchemaValidator.Validate("\"abcdef\"", schema)[0].Should().Contain("maxLength");
+        JsonSchemaValidator.Validate("\"AB\"", schema).Should().Contain(e => e.Contains("pattern"));
+        JsonSchemaValidator.Validate("\"abc\"", schema).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void String_InvalidPattern_IsIgnored()
+    {
+        // 非法正则（未闭合括号）——校验器必须忽略而不是抛出。
+        var schema = """{"type":"string","pattern":"[unclosed"}""";
+        var act = () => JsonSchemaValidator.Validate("\"anything\"", schema);
+        act.Should().NotThrow();
+    }
+
+    [Fact]
+    public void Array_Constraints_AllBranches()
+    {
+        var schema = """
+            { "type": "array", "minItems": 2, "maxItems": 3, "uniqueItems": true }
+            """;
+        JsonSchemaValidator.Validate("[1]", schema)[0].Should().Contain("minItems");
+        JsonSchemaValidator.Validate("[1,2,3,4]", schema)[0].Should().Contain("maxItems");
+        JsonSchemaValidator.Validate("[1,1]", schema).Should().Contain(e => e.Contains("not unique"));
+        JsonSchemaValidator.Validate("[1,2]", schema).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Array_ItemsSchema_AppliedToElements()
+    {
+        var schema = """{"type":"array","items":{"type":"integer"}}""";
+        JsonSchemaValidator.Validate("[1, \"x\"]", schema).Should().Contain(e => e.Contains("integer"));
+        JsonSchemaValidator.Validate("[1, 2]", schema).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Object_AdditionalProperty_Branches()
+    {
+        var noAdditional = """{"type":"object","properties":{"a":{"type":"string"}},"additionalProperties":false}""";
+        JsonSchemaValidator.Validate("""{"a":"x","b":1}""", noAdditional)
+            .Should().Contain(e => e.Contains("not allowed"));
+
+        var typedAdditional = """{"type":"object","properties":{"a":{"type":"string"}},"additionalProperties":{"type":"number"}}""";
+        JsonSchemaValidator.Validate("""{"a":"x","b":"not-a-number"}""", typedAdditional)
+            .Should().Contain(e => e.Contains("number"));
+
+        JsonSchemaValidator.Validate("""{"a":"x","b":7}""", typedAdditional).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Ref_UnknownPointer_ReportsError()
+    {
+        var schema = """{"$ref":"#/definitions/missing","definitions":{}}""";
+        var errors = JsonSchemaValidator.Validate("42", schema);
+        errors.Should().Contain(e => e.Contains("$ref") || e.Contains("missing"));
+    }
+
+    [Fact]
+    public void Ref_EscapedPointerSegments_Resolve()
+    {
+        // ~1 = /，~0 = ~ 的 JSON Pointer 转义。
+        var schema = """
+            {
+                "$ref": "#/definitions/a~1b",
+                "definitions": { "a/b": { "type": "string" } }
+            }
+            """;
+        JsonSchemaValidator.Validate("\"ok\"", schema).Should().BeEmpty();
+        JsonSchemaValidator.Validate("42", schema).Should().NotBeEmpty();
+    }
+
+    [Fact]
+    public void Enum_MismatchReports_NonStringValues()
+    {
+        var schema = """{"enum":[1,2,3]}""";
+        JsonSchemaValidator.Validate("4", schema).Should().Contain(e => e.Contains("enum"));
+        JsonSchemaValidator.Validate("2", schema).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Const_MismatchReports()
+    {
+        var schema = """{"const":"v1"}""";
+        JsonSchemaValidator.Validate("\"v2\"", schema).Should().NotBeEmpty();
+        JsonSchemaValidator.Validate("\"v1\"", schema).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void Integer_Type_ChecksIntegralForm()
+    {
+        var schema = """{"type":"integer"}""";
+        JsonSchemaValidator.Validate("1.5", schema).Should().NotBeEmpty();
+        JsonSchemaValidator.Validate("1e3", schema).Should().NotBeEmpty();
+        JsonSchemaValidator.Validate("7", schema).Should().BeEmpty();
+    }
+
+    [Fact]
+    public void TypeNames_InErrorMessages()
+    {
+        var schema = """{"type":"string"}""";
+        foreach (var payload in new[] { "42", "true", "null", "[1]", """{"k":1}""" })
+        {
+            var errors = JsonSchemaValidator.Validate(payload, schema);
+            errors.Should().NotBeEmpty($"payload {payload} is not a string");
+        }
+    }
+}