C# Random增强类 1.0

鉴于c#的random类功能略弱，于是自己封装了一下。当中部分的实现还不怎么满意，希望大牛能指点一下。另外，随机枚举的思路感谢博客园的鹤冲天。

namespace System
{
    /// <summary>
    /// 伪随机数扩展类
    /// </summary>
    public static partial class RandomExt
    {
        private static readonly Random _rand;

        static RandomExt()
        {
            _rand = new Random();
        }

        /// <summary>
        /// 返回随机真假。
        /// </summary>
        /// <returns>真或假。</returns>
        public static bool NextBool()
        {
            return _rand.Next(2) == 0;
        }

        /// <summary>
        /// 返回随机字节。
        /// </summary>
        /// <returns>大于等于零且小于 MaxValue 的无符号 8 位整数。</returns>
        public static byte NextByte()
        {
            byte[] buffer = new byte[1];
            _rand.NextBytes(buffer);
            return buffer[0];
        }

        /// <summary>
        /// 返回一个小于所指定最大值的字节。
        /// </summary>
        /// <param name="maxValue">要生成的随机字节的上限（随机字节不能取该上限值）。 maxValue 必须大于或等于零。</param>
        /// <returns>大于等于且小于 maxValue 的无符号 8 位整数，即：返回值的范围通常包括零但不包括 maxValue。 不过，如果 maxValue 等于零，则返回 maxValue。</returns>
        public static byte NextByte(byte maxValue)
        {
            return (byte)_rand.Next(maxValue);
        }

        /// <summary>
        /// 返回一个指定范围内的随机字节。
        /// </summary>
        /// <param name="minValue">返回的随机字节的下界（随机字节可取该下界值）。</param>
        /// <param name="maxValue">返回的随机字节的上界（随机字节不能取该上界值）。 maxValue 必须大于或等于 minValue。</param>
        /// <returns>一个大于等于 minValue 且小于 maxValue 的无符号 8 位整数，即：返回的值范围包括 minValue 但不包括 maxValue。 如果 minValue 等于 maxValue，则返回 minValue。</returns>
        public static byte NextByte(byte minValue, byte maxValue)
        {
            return (byte)_rand.Next(minValue, maxValue);
        }

        /// <summary>
        /// 用随机数填充指定字节数组的元素。
        /// </summary>
        /// <param name="buffer">包含随机数的字节数组。</param>
        public static void NextBytes(byte[] buffer)
        {
            _rand.NextBytes(buffer);
        }

        /// <summary>
        /// 用随机数填充指定长度的字节数组。
        /// </summary>
        /// <param name="length">字节数组长度。</param>
        /// <returns>包含随机数的字节数组。</returns>
        public static byte[] NextBytes(int length)
        {
            byte[] buffer = new byte[length];
            _rand.NextBytes(buffer);
            return buffer;
        }

        /// <summary>
        /// 返回随机数。
        /// </summary>
        /// <param name="containNegative">是否包含负数。</param>
        /// <returns>返回一个随机的 Decimal。</returns>
        public static decimal NextDecimal(bool containNegative = false)
        {
            byte[] buffer = new byte[4];
            _rand.NextBytes(buffer);
            int lo = BitConverter.ToInt32(buffer, 0);// 96 位整数的低 32 位。
            _rand.NextBytes(buffer);
            int mid = BitConverter.ToInt32(buffer, 0);// 96 位整数的中间 32 位。
            _rand.NextBytes(buffer);
            int hi = BitConverter.ToInt32(buffer, 0);// 96 位整数的高 32 位。
            bool isNegative = containNegative == false ? false : _rand.Next(2) == 0;// 正或负
            byte scale = (byte)_rand.Next(29);// 10 的指数（0 到 28 之间）。
            return new decimal(lo, mid, hi, isNegative, scale);
        }

        /// <summary>
        /// 返回一个小于所指定最大值的非负随机数。
        /// </summary>
        /// <param name="maxValue">要生成的随机数的上限（随机数不能取该上限值）。 maxValue 必须大于或等于零。</param>
        /// <returns>大于等于零且小于 maxValue 的 Decimal，即：返回值的范围通常包括零但不包括 maxValue。 不过，如果 maxValue 等于零，则返回 maxValue。</returns>
        public static decimal NextDecimal(decimal maxValue)
        {
            if (maxValue == 0)
            {
                return maxValue;
            }
            if (maxValue < 0)
            {
                throw new ArgumentOutOfRangeException("“maxValue”必须大于 0。", "maxValue");
            }
            decimal d;
            byte[] buffer = new byte[4];
            do
            {
                _rand.NextBytes(buffer);
                int lo = BitConverter.ToInt32(buffer, 0);// 96 位整数的低 32 位。
                _rand.NextBytes(buffer);
                int mid = BitConverter.ToInt32(buffer, 0);// 96 位整数的中间 32 位。
                _rand.NextBytes(buffer);
                int hi = BitConverter.ToInt32(buffer, 0);// 96 位整数的高 32 位。
                byte scale = (byte)_rand.Next(29);// 10 的指数（0 到 28 之间）。
                d = new decimal(lo, mid, hi, false, scale);
            } while ((d < maxValue) == false);
            return d;
        }

        /// <summary>
        /// 返回一个指定范围内的随机数。
        /// </summary>
        /// <param name="minValue">返回的随机数的下界（随机数可取该下界值）。</param>
        /// <param name="maxValue">返回的随机数的上界（随机数不能取该上界值）。 maxValue 必须大于或等于 minValue。</param>
        /// <returns>一个大于等于 minValue 且小于 maxValue 的 Decimal，即：返回的值范围包括 minValue 但不包括 maxValue。 如果 minValue 等于 maxValue，则返回 minValue。</returns>
        public static decimal NextDecimal(decimal minValue, decimal maxValue)
        {
            if (minValue == maxValue)
            {
                return minValue;
            }
            if (minValue > maxValue)
            {
                throw new ArgumentOutOfRangeException("“minValue”不能大于 maxValue。", "minValue");
            }
            decimal d;