如何在客户端（JavaScript）与服务端（C#）生成相同伪随机数？

核心思路是在两端实现完全相同的伪随机数生成算法，而非依赖各自语言的内置库。以下是具体可行的方案：

1. 选择兼容算法 #

优先挑选算法逻辑公开、无语言依赖、运算规则明确的PRNG，避免因语言特性差异导致序列不一致。推荐两类：

• LCG（线性同余生成器）：实现最简单，适合快速落地，随机性满足一般场景需求。
• Xorshift128+：现代PRNG，随机性更好、周期更长，适合对随机数质量要求高的场景。

2. 具体实现示例 #

方案一：LCG实现 #

使用经典的LCG参数（来自Numerical Recipes），确保两端运算完全一致：

C# 代码

public class LcgPrng
{
    private ulong _state;
    // 固定参数，两端必须完全一致
    private const ulong A = 1664525;
    private const ulong C = 1013904223;
    private const ulong M = 1UL << 32;

    public LcgPrng(ulong seed)
    {
        _state = seed;
    }

    // 生成32位无符号整数
    public uint NextUInt32()
    {
        _state = (A * _state + C) % M;
        return (uint)_state;
    }

    // 生成0-1之间的浮点数
    public double NextDouble()
    {
        return NextUInt32() / (double)uint.MaxValue;
    }
}

JavaScript 代码

用BigInt处理整数运算，避免Number类型的精度丢失：

class LcgPrng {
    constructor(seed) {
        this.state = BigInt(seed);
        // 与C#完全一致的参数
        this.A = 1664525n;
        this.C = 1013904223n;
        this.M = 1n << 32n;
    }

    nextUInt32() {
        this.state = (this.A * this.state + this.C) % this.M;
        return Number(this.state);
    }

    nextDouble() {
        return this.nextUInt32() / 4294967295; // 对应uint.MaxValue的数值
    }
}

方案二：Xorshift128+实现（更高质量） #

适合对随机性要求高的场景，周期长达2^128-1：

C# 代码

public class Xorshift128Plus
{
    private ulong _s0, _s1;

    public Xorshift128Plus(ulong seed)
    {
        _s0 = seed;
        // 初始化第二个状态，避免全0导致序列失效
        _s1 = seed ^ 0xDEADBEEFDEADBEEF;
    }

    public ulong NextUInt64()
    {
        ulong x = _s0;
        ulong y = _s1;
        _s0 = y;
        x ^= x << 23;
        _s1 = x ^ y ^ (x >> 17) ^ (y >> 26);
        return _s1 + y;
    }

    public double NextDouble()
    {
        // 取高53位转换为浮点数，避免JS Number精度限制
        return (NextUInt64() >> 11) / (double)(1UL << 53);
    }
}

JavaScript 代码

class Xorshift128Plus {
    constructor(seed) {
        this.s0 = BigInt(seed);
        this.s1 = BigInt(seed) ^ 0xDEADBEEFDEADBEEFn;
    }

    nextUInt64() {
        let x = this.s0;
        let y = this.s1;
        this.s0 = y;
        x ^= x << 23n;
        this.s1 = x ^ y ^ (x >> 17n) ^ (y >> 26n);
        return this.s1 + y;
    }

    nextDouble() {
        const bits = this.nextUInt64() >> 11n;
        return Number(bits) / Number(1n << 53n);
    }
}

3. 使用方式 #

两端用完全相同的种子初始化PRNG实例，调用对应方法即可生成完全一致的随机数序列。例如：

• C#端：var prng = new LcgPrng(12345); var num = prng.NextDouble();
• JS端：const prng = new LcgPrng(12345); const num = prng.nextDouble();
  两者得到的num数值完全一致。

关键注意事项 #

• 参数绝对统一：算法的所有参数（如LCG的A/C/M、Xorshift的移位位数）两端必须完全相同，差一个值都会导致序列完全不同。
• 数值类型兼容：整数运算必须用相同位数的无符号整数处理，JS中务必用BigInt避免精度丢失，C#中对应使用ulong/uint类型。
• 浮点数转换一致：生成0-1浮点数时，两端的除数必须对应相同的最大值（如uint.MaxValue或2^53）。

内容的提问来源于stack exchange，提问作者Jez