产生 可重复 和 不可重复 的随机数

//

//

//功能：产生随机数

//日期：.7.16

//作者：xiage

//

//

  

 

public class _Random

    {

        /// <summary>

        /// 返回minxValue -- maxValue 之间的count 维数组;          

        /// [条件]:

        ///      1.minxValue必须小于或等于maxValue;

        ///      2.count 必须大于0;

        ///      3.如果isRepeat 为ture 则maxValue 和minxValue 之差必须大于或等于count;

        ///      4.取下限(minxValue)不取上限(maxValue);

        /// </summary>

        /// <param name="count">维数--生成随机数的个数</param>

        /// <param name="minxValue">最小值</param>

        /// <param name="maxValue">最大值</param>

        /// <returns>返回正整数范围内的随机数组</returns>

        public static int[] GetRandomNumber(int count, int minxValue, int maxValue, bool isRepeat)

        {

            #region......摘要......

            //

            //  摘要：此属性的值表示自0001 年1 月1 日午夜12:00:00 以来已经过的时间的以100 毫微秒为间隔的间隔数。

            //

            //       DateTime.Now.Ticks

            //       表示此实例的日期和时间的刻度数。该值介于MinValue 和MaxValue 之间

            // 

            //       MinValue:此常数的值等效于0001 年1 月1 日00:00:00.0000000 

            // 

            //       MaxValue:此常数的值等效于9999 年12 月31 日23:59:59.9999999，

            //                恰好在10000 年1 月1 日00:00:00 之前一个100 毫微秒刻度处。

 

            //

            //  unchecked 关键字用于取消整型算术运算和转换的溢出检查.

            //

 

            #endregion

 

            if (count <= 0) return (new int[0]);

 

            if (minxValue > maxValue) return (new int[0]);

 

            if ((maxValue - minxValue) < count) return (new int[0]);

 

            Int32[] RandomArray = new int[count];

 

            Random rad = new Random(unchecked((int)DateTime.Now.Ticks));

 

            for (int i = 0; i < count; i++)

            {

                int caCheNum = rad.Next(minxValue, maxValue);

                int identity = GetRandNum(minxValue, maxValue, RandomArray, caCheNum, rad, isRepeat);

                if (isRepeat)

                    RandomArray[i] = caCheNum;

                else

                {

                    RandomArray[i] = identity;

                }

            }

            return RandomArray;

        }

        /// <summary>

        /// 返回正整数范围内的随机数组

        /// </summary>

        /// <param name="count">生成随机数的个数</param>

        /// <returns>返回正整数范围内的随机数组,不重复的</returns>

        public static int[] GetRandomNumber(int count)

        {

            return GetRandomNumber(count, 0, Int32.MaxValue, false);

        }

        /// <summary>

        /// 返回正整数范围内的随机数组

        /// </summary>

        /// <param name="count">生成随机数的个数</param>

        /// <returns>返回正整数范围内的随机数组,自定义是否重复</returns>       

        public static int[] GetRandomNumber(int count, bool isRepeat)

        {

            return GetRandomNumber(count, 0, Int32.MaxValue, isRepeat);

        }

        /// <summary>

        /// 返回正整数范围内的随机数

        /// </summary>

        /// <returns>返回正整数范围内的随机数</returns>

        public static int GetRandomNumber()

        {

            return GetRandomNumber(1, 0, Int32.MaxValue, false)[0];

        }

        /// <summary>

        ///  /// 返回随机字母数组

        /// 摘要：

        ///      参数style:

        ///                0:大写字母的随机

        ///                1:小写字母的随机

        ///                2:大小写混合随机

        /// </summary>

        /// <param name="style">字母类型；:大写字母,1:小写字母,2:大小写混合</param>

        /// <param name="count">产生随机字母的数量</param>

        /// <param name="isRepeat">是否重复</param>

        /// <returns></returns>

        public static string[] GetRandomLetter(int style, int count, bool isRepeat)

        {

 

            if (count <= 0) return (new string[0]);

            string ArrayUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

            string ArrayLower = "abcdefghijklmnopqrstuvwxyz";

            string ArrayMerge = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

 

            string[] chCheArray = new string[count];

 

            int[] chCheNum = GetRandomNumber(count, 0, 26, isRepeat);

            int[] chCheNumM = GetRandomNumber(count, 0, 52, isRepeat);

            switch (style)

            {

                case 0:

                    return ReturnCharArray(ArrayUpper, chCheNum);

                case 1:

                    return ReturnCharArray(ArrayLower, chCheNum);

                case 2:

                    return ReturnCharArray(ArrayMerge, chCheNumM);

                default:

                    return ReturnCharArray(ArrayUpper, chCheNum);

 

            }

        }

        /// <summary>

        /// 返回长度为count 的随机字符串(大写)

        /// </summary>

        /// <param name="count">字符串长度</param>

        /// <returns></returns>

        public static string GetRandomString(int count)

        {

            return string.Join("", GetRandomLetter(0, count, false));

        }

        /// <summary>

        /// 返回长度为1 的随机字符串(大写)

        /// </summary>

        /// <returns></returns>

        public static string GetRandomString()

        {

            return string.Join("", GetRandomLetter(0, 1, false));

        }

        /// <summary>

        /// 返回随机字符数组

        /// </summary>

        /// <param name="letterStr">字母串</param>

        /// <param name="randomNum">随机数数组</param>

        /// <returns></returns>

        private static string[] ReturnCharArray(string letterStr, int[] randomNum)

        {

            string[] caChe = new string[randomNum.Length];

            for (int i = 0; i < randomNum.Length; i++)

            {

                caChe[i] = letterStr[randomNum[i]].ToString();

            }

            return caChe;

        }

 

        /// <summary>

        /// 生成唯一性

        /// </summary>

        /// <param name="minxValue">随机数下限</param>

        /// <param name="maxValue">随机数上限</param>

        /// <param name="RandomArray">存储随机数的数组</param>

        /// <param name="CheckedNum">需要验证的随机数</param>

        /// <param name="rad">随机对象</param>

        /// <param name="isRepeat">是否重复</param>

        /// <returns>返回随机数</returns>

        private static Int32 GetRandNum(int minxValue, int maxValue, Int32[] RandomArray, Int32 CheckedNum, Random rad, bool isRepeat)

        {

            //可重复随机数

            if (isRepeat)

            {

                return CheckedNum;

            }

            else

            {

                //不重复随机数，遍历数组，检查当前产生的随机数是否已经存在于数组中

                for (int i = 0; i < RandomArray.Length; i++)

                {

                    if (CheckedNum == RandomArray[i])

                    {

                        int caCheNum = rad.Next(minxValue, maxValue);

                        //递归直到产生和数组中元素不同的随机数

                        CheckedNum = GetRandNum(minxValue, maxValue, RandomArray, caCheNum, rad, isRepeat);

                    }

                }

                return CheckedNum;

            }

        }

    }