如何对基类IEnumerable调用Linq的Take()方法？

我来帮你完善这个随机字节生成器的实现，顺便修正几个容易踩坑的细节～

你要实现两个类：

• RandomBytes：一个无限枚举的随机字节生成器，能持续输出随机字节
• RandomNBytes：继承自RandomBytes，仅生成指定数量（N个）的随机字节

首先修正RandomBytes的几个问题，再补全RandomNBytes的实现：

using System;
using System.Collections;
using System.Collections.Generic;

public class RandomBytes : IEnumerable<byte>, IEnumerable
{
    // 把Random实例提升为类字段，避免频繁创建导致随机数重复
    private readonly Random _rnd;

    public RandomBytes()
    {
        _rnd = new Random();
    }

    // 可选：允许传入自定义Random实例，方便测试时用固定种子复现结果
    public RandomBytes(Random rnd)
    {
        _rnd = rnd ?? throw new ArgumentNullException(nameof(rnd));
    }

    public IEnumerator<byte> GetEnumerator()
    {
        while (true)
        {
            // 注意：Random.Next的上限是排他的！原代码Next(0,255)只能生成0-254
            yield return (byte)_rnd.Next(0, 256);
        }
    }

    // 实现非泛型接口，直接复用泛型枚举器
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class RandomNBytes : RandomBytes
{
    private readonly ulong _count;

    // 公开构造函数，指定要生成的字节数
    public RandomNBytes(ulong count) : this(count, new Random())
    {
    }

    // 重载构造函数，支持传入自定义Random实例
    public RandomNBytes(ulong count, Random rnd) : base(rnd)
    {
        if (count == 0)
            throw new ArgumentOutOfRangeException(nameof(count), "生成的字节数不能为0");
        _count = count;
    }

    // 重写枚举器，限制输出数量
    public override IEnumerator<byte> GetEnumerator()
    {
        using var baseEnumerator = base.GetEnumerator();
        for (ulong i = 0; i < _count; i++)
        {
            baseEnumerator.MoveNext();
            yield return baseEnumerator.Current;
        }
    }

    // 同步重写非泛型枚举器
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

1. Random实例的优化：
   原代码在GetEnumerator里每次创建Random，短时间内多次调用会因为系统时钟种子重复，导致生成相同的随机序列。把Random作为类字段初始化，能避免这个问题。

2. Random.Next的参数修正：
   Random.Next(min, max)的max是排他值，原代码Next(0,255)只能生成0-254的字节，改成Next(0,256)才能覆盖完整的0-255字节范围。

3. RandomNBytes的实现逻辑：
   通过重写GetEnumerator，复用父类的随机生成逻辑，同时用循环限制输出次数。这种方式能兼容ulong类型的大数量（比如超过int.MaxValue的场景），比用Enumerable.Take更稳妥。

// 生成10个随机字节并遍历
var tenRandomBytes = new RandomNBytes(10);
foreach (byte b in tenRandomBytes)
{
    Console.WriteLine(b);
}

// 转换为字节数组
byte[] byteArray = tenRandomBytes.ToArray();

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