//******************************************************************************************************//  Random.cs - Gbtc////  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  01/04/2006 - J. Ritchie Carroll//       Generated original version of source code.//  09/17/2008 - J. Ritchie Carroll//       Converted to C#.//  02/16/2009 - Josh L. Patterson//       Edited Code Comments.//  09/14/2009 - Stephen C. Wills//       Added new header and license agreement.//  12/14/2012 - Starlynn Danyelle Gilliam//       Modified Header.////****************************************************************************************************** using System;using System.Security.Cryptography; namespace GSF.Security.Cryptography{    /// <summary>    /// Generates cryptographically strong random numbers.    /// </summary>    public static class Random    {        private static readonly RNGCryptoServiceProvider RandomNumberGenerator = new RNGCryptoServiceProvider();         /// <summary>        /// Generates a cryptographically strong double-precision floating-point random number between zero and one.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static double Number        {            get            {                unchecked                {                    return UInt32 / (uint.MaxValue + 1.0D);                }            }        }         /// <summary>        /// Generates a cryptographically strong random decimal between zero and one.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static decimal Decimal        {            get            {                unchecked                {                    return UInt64 / (ulong.MaxValue + 1.0M);                }            }        }         /// <summary>        /// Generates a cryptographically strong random integer between specified values.        /// </summary>        /// <param name="startNumber">A <see cref="double"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="double"/> that is the high end of our range.</param>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <returns>A <see cref="double"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>, or an excception.</returns>        public static double Between(double startNumber, double stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return Number * (stopNumber - startNumber) + startNumber;        }         /// <summary>        /// Fills an array of bytes with a cryptographically strong sequence of random values.        /// </summary>        /// <param name="buffer">The array to fill with a cryptographically strong sequence of random values.</param>        /// <remarks>        /// <para>The length of the byte array determines how many cryptographically strong random bytes are produced.</para>        /// <para>This method is thread safe.</para>        /// </remarks>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <exception cref="ArgumentNullException">buffer is null.</exception>        public static void GetBytes(byte[] buffer)        {            RandomNumberGenerator.GetBytes(buffer);        }         /// <summary>        /// Generates a cryptographically strong random boolean (i.e., a coin toss).        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static bool Boolean        {            get            {                byte[] value = new byte[1];                 RandomNumberGenerator.GetBytes(value);                 return value[0] % 2 == 0;            }        }         /// <summary>        /// Generates a cryptographically strong 8-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static byte Byte        {            get            {                byte[] value = new byte[1];                 RandomNumberGenerator.GetBytes(value);                 return value[0];            }        }         /// <summary>        /// Generates a cryptographically strong 8-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="byte"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="byte"/> that is the high end of our range.</param>        /// <returns>A <see cref="byte"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static byte ByteBetween(byte startNumber, byte stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (byte)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong 16-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static short Int16        {            get            {                byte[] value = new byte[2];                 RandomNumberGenerator.GetBytes(value);                 return BitConverter.ToInt16(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong 16-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="short"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="short"/> that is the high end of our range.</param>        /// <returns>A <see cref="short"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static short Int16Between(short startNumber, short stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (short)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong unsigned 16-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static ushort UInt16        {            get            {                byte[] value = new byte[2];                 RandomNumberGenerator.GetBytes(value);                 return BitConverter.ToUInt16(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong unsigned 16-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="ushort"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="ushort"/> that is the high end of our range.</param>        /// <returns>A <see cref="ushort"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static ushort UInt16Between(ushort startNumber, ushort stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (ushort)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong 24-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static Int24 Int24        {            get            {                byte[] value = new byte[3];                 RandomNumberGenerator.GetBytes(value);                 return Int24.GetValue(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong 24-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="Int24"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="Int24"/> that is the high end of our range.</param>        /// <returns>A <see cref="Int24"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static Int24 Int24Between(Int24 startNumber, Int24 stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (Int24)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong unsigned 24-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static UInt24 UInt24        {            get            {                byte[] value = new byte[3];                 RandomNumberGenerator.GetBytes(value);                 return UInt24.GetValue(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong unsigned 24-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="UInt24"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="UInt24"/> that is the high end of our range.</param>        /// <returns>A <see cref="UInt24"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static UInt24 Int24Between(UInt24 startNumber, UInt24 stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (UInt24)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong 32-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static int Int32        {            get            {                byte[] value = new byte[4];                 RandomNumberGenerator.GetBytes(value);                 return BitConverter.ToInt32(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong 32-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="int"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="int"/> that is the high end of our range.</param>        /// <returns>A <see cref="int"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static int Int32Between(int startNumber, int stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (int)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong unsigned 32-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static uint UInt32        {            get            {                byte[] value = new byte[4];                 RandomNumberGenerator.GetBytes(value);                 return BitConverter.ToUInt32(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong unsigned 32-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="uint"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="uint"/> that is the high end of our range.</param>        /// <returns>A <see cref="uint"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static uint UInt32Between(uint startNumber, uint stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (uint)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong 64-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static long Int64        {            get            {                byte[] value = new byte[8];                 RandomNumberGenerator.GetBytes(value);                 return BitConverter.ToInt64(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong 64-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="long"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="long"/> that is the high end of our range.</param>        /// <returns>A <see cref="long"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static long Int64Between(long startNumber, long stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (long)(Number * (stopNumber - startNumber) + startNumber);        }         /// <summary>        /// Generates a cryptographically strong unsigned 64-bit random integer.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        public static ulong UInt64        {            get            {                byte[] value = new byte[8];                 RandomNumberGenerator.GetBytes(value);                 return BitConverter.ToUInt64(value, 0);            }        }         /// <summary>        /// Generates a cryptographically strong unsigned 64-bit random integer between specified values.        /// </summary>        /// <exception cref="CryptographicException">The cryptographic service provider (CSP) cannot be acquired.</exception>        /// <param name="startNumber">A <see cref="ulong"/> that is the low end of our range.</param>        /// <param name="stopNumber">A <see cref="ulong"/> that is the high end of our range.</param>        /// <returns>A <see cref="ulong"/> that is generated between the <paramref name="startNumber"/> and the <paramref name="stopNumber"/>.</returns>        public static ulong UInt64Between(ulong startNumber, ulong stopNumber)        {            if (stopNumber < startNumber)                throw new ArgumentException("stopNumber must be greater than startNumber");             return (ulong)(Number * (stopNumber - startNumber) + startNumber);        }    }}