Rasgele bir int numarası nasıl oluştururum?

Nasıl C # rastgele bir tamsayı oluştururum?

RandomSınıf rasgele sayılar oluşturmak için kullanılır. (Pseudo-random tabii ki.).

Misal:

Random rnd = new Random();
int month  = rnd.Next(1, 13);  // creates a number between 1 and 12
int dice   = rnd.Next(1, 7);   // creates a number between 1 and 6
int card   = rnd.Next(52);     // creates a number between 0 and 51

Birden fazla rasgele sayı oluşturacaksanız, Randomörneği saklamalı ve yeniden kullanmalısınız. Zaman içinde çok yakın yeni örnekler oluşturursanız, rastgele üretecin sistem saatinden tohumlanmasıyla aynı rastgele sayılar dizisini üretirler.

Soru çok basit görünüyor ama cevap biraz karmaşık. Görüyorsanız neredeyse herkes Random sınıfını kullanmayı önerdi ve bazıları RNG kripto sınıfını kullanmayı önerdi. Ama sonra ne zaman seçilir.

Bunun için önce RANDOMNESS terimini ve arkasındaki felsefeyi anlamamız gerekir.

C # kullanarak https://www.youtube.com/watch?v=tCYxc-2-3fY RANDOMNESS felsefesinde derinlemesine ilerleyen bu videoyu izlemenizi öneririm.

İlk şey, RASTİKLİK felsefesini anlamamıza izin verir. Bir kişiye KIRMIZI, YEŞİL ve SARI arasında seçim yapmasını söylediğimizde, dahili olarak ne olur. Bir kişinin KIRMIZI veya SARI veya YEŞİL'i seçmesini sağlayan nedir?

Bazı ilk düşünceler seçimine karar veren kişilerin zihnine girer, favori renk, şanslı renk ve benzeri olabilir. Başka bir deyişle, RANDOM'da SEED olarak adlandırdığımız bazı başlangıç ​​tetikleyicileriBu TOED başlangıç ​​noktasıdır, RANDOM değerini seçmesini teşvik eden tetikleyicidir.

Şimdi bir SEED'in tahmin edilmesi kolaysa, bu tür rastgele sayılar PSEUDO olarak adlandırılır ve bir tohumun tahmin edilmesi zor olduğunda bu rastgele sayılar GÜVENLİ rastgele sayılar olarak adlandırılır .

Örneğin, bir kişi hava ve ses kombinasyonuna bağlı olarak renk seçer, o zaman ilk tohumu tahmin etmek zor olurdu.

Şimdi önemli bir açıklama yapmama izin verin: -

* “Rasgele” sınıf sadece PSEUDO rasgele sayı üretir ve GÜVENLİ rasgele sayı üretmek için “RNGCryptoServiceProvider” sınıfını kullanmamız gerekir.

Rastgele sınıf, çok değerli olan CPU saatinizden tohum değerleri alır. Başka bir deyişle, C # RANDOM sınıfı sözde rasgele sayılar üretir, aşağıda aynı kod.

** Not: ** .NET Core 2.0.0+parametresiz kurucuda farklı bir tohum kullanır : kullandığı CPU saati yerine Guid.NewGuid().GetHashCode().

var random = new Random();
int randomnumber = random.Next()

İken RNGCryptoServiceProvidersınıfın kullandığı işletim tohumlarını üretmek için entropi. OS entropi, ses, fare tıklaması ve klavye zamanlamaları, termal sıcaklık vb. Kullanılarak oluşturulan rastgele bir değerdir. Aşağıda aynı kod bulunmaktadır.

using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider()) 
{ 
    byte[] rno = new byte[5];    
    rg.GetBytes(rno);    
    int randomvalue = BitConverter.ToInt32(rno, 0); 
}

OS entropisini anlamak için, OS entropisinin mantığının açıklandığı 14:30 https://www.youtube.com/watch?v=tCYxc-2-3fY adresinden bu videoyu izleyin . Basit bir deyişle, RNG Crypto GÜVENLİ rasgele sayılar üretir.

Her yeni Random () yaptığınızda başlatılır. Bu, sıkı bir döngüde aynı değeri birçok kez elde ettiğiniz anlamına gelir. Tek bir Random örneği tutmalı ve Next'i aynı örnekte kullanmaya devam etmelisiniz.

//Function to get random number
private static readonly Random getrandom = new Random();

public static int GetRandomNumber(int min, int max)
{
    lock(getrandom) // synchronize
    {
        return getrandom.Next(min, max);
    }
}

new Random()Mevcut zaman damgasına ekilen sakının .

Yalnızca bir sayı oluşturmak istiyorsanız şunları kullanabilirsiniz:

new Random().Next( int.MinValue, int.MaxValue )

Daha fazla bilgi için Rastgele sınıfa bakın, ancak lütfen unutmayın:

Bununla birlikte, saatin sonlu çözünürlüğü olduğundan, yakın zamanda farklı Rastgele nesneler oluşturmak için parametresiz yapıcıyı kullanmak, rasgele sayıların aynı dizilerini üreten rastgele sayı üreteçleri oluşturur

Bu nedenle, rastgele bir sayı dizisi oluşturmak için bu kodu kullanmayın.

Random r = new Random();
int n = r.Next();

Kriptografik olarak güvenli bir sürüm eklemek istedim:

RNGCryptoServiceProvider Sınıfı ( MSDN veya dotnetperls )

IDisposable uygular.

using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
   byte[] randomNumber = new byte[4];//4 for int32
   rng.GetBytes(randomNumber);
   int value = BitConverter.ToInt32(randomNumber, 0);
}

Sahte rasgele bir sayı için oluşturduğu MiscUtil sınıf kütüphanesinde Jon Skeet'in StaticRandom yöntemini kullanabilirsiniz .

using MiscUtil;
...

for (int i = 0; i < 100; 
    Console.WriteLine(StaticRandom.Next());

COBOL yanıtı hariç tüm bu çözümleri denedim ... lol

Bu çözümlerin hiçbiri yeterince iyi değildi. Int döngüsü için hızlı bir şekilde rastgele ihtiyacım vardı ve çok geniş aralıklarda bile tonlarca yinelenen değer elde ediyordum. Rastgele sonuçlara çok uzun süre karar verdikten sonra sonunda bu sorunu bir kez ve herkes için çözmeye karar verdim.

Her şey tohumla ilgili.

Guid'den basamak olmayan rakamları ayrıştırarak rastgele bir tamsayı oluşturuyorum, sonra bunu Random sınıfımı başlatmak için kullanıyorum.

public int GenerateRandom(int min, int max)
{
    var seed = Convert.ToInt32(Regex.Match(Guid.NewGuid().ToString(), @"\d+").Value);
    return new Random(seed).Next(min, max);
}

Güncelleme : Random sınıfını bir kez başlatırsanız tohumlama gerekli değildir. Bu yüzden statik bir sınıf oluşturmak ve bunun dışında bir yöntem çağırmak en iyisidir.

public static class IntUtil
{
   private static Random random;

   private static void Init()
   {
      if (random == null) random = new Random();
   }

   public static int Random(int min, int max)
   {
      Init();
      return random.Next(min, max);
   }
}

Sonra böyle statik sınıfı kullanabilirsiniz ..

for(var i = 0; i < 1000; i++)
{
   int randomNumber = IntUtil.Random(1,100);
   Console.WriteLine(randomNumber); 
}

Bu yaklaşımı daha çok sevdiğimi itiraf ediyorum.

Dahili tarafından üretilen sayılar Random sınıf (System.Random) tarafından üretilen sayılar sahte rasgele sayılar üretir.

Eğer gerçek rastgele sayılar istiyorsanız, en yakın "güvenli sözde rastgele jeneratör" C # gibi Cryptographic sınıfları kullanılarak oluşturulabilir RNGCryptoServiceProvider .

Yine de, gerçek rasgele sayılara ihtiyacınız varsa, rasgele sayı üreteci için bir tohum olarak radyoaktif bozulmayı açıklayan cihazlar gibi harici bir kaynak kullanmanız gerekecektir. Tanım gereği, tamamen algoritmik yollarla üretilen herhangi bir sayı gerçekten rastgele olamaz.

Rastgele bir nesne yarat

Random rand = new Random();

ve kullan

int randomNumber = rand.Next(min, max);

Eğer başlatmak zorunda değilsiniz new Random()biri Rastgele başlatmak Eğer bir döngü ya da her türlü iç ihtiyaç olarak daha sonra birçok kez olarak kullanabilirsiniz, bir rastgele sayı gerekir her zaman

Buradan değiştirilmiş cevap .

Intel Secure Key uyumlu bir CPU'ya erişiminiz varsa, şu kütüphaneleri kullanarak gerçek rasgele sayılar ve dizeler oluşturabilirsiniz: https://github.com/JebteK/RdRand ve https://www.rdrand.com/

En son sürümü buradan indirin , Jebtek.RdRand'i ekleyin ve bunun için bir kullanım ifadesi ekleyin. O zaman tek yapmanız gereken şudur:

// Check to see if this is a compatible CPU
bool isAvailable = RdRandom.GeneratorAvailable();

// Generate 10 random characters
string key       = RdRandom.GenerateKey(10);

 // Generate 64 random characters, useful for API keys 
string apiKey    = RdRandom.GenerateAPIKey();

// Generate an array of 10 random bytes
byte[] b         = RdRandom.GenerateBytes(10);

// Generate a random unsigned int
uint i           = RdRandom.GenerateUnsignedInt();

Kodu çalıştırmak için uyumlu bir CPU'nuz yoksa, rdrand.com adresindeki RESTful hizmetlerini kullanın. Projenize dahil olan RdRandom sarıcı kütüphanesi ile bunu yapmanız yeterlidir (kayıt olduğunuzda 1000 ücretsiz çağrı alırsınız):

string ret = Randomizer.GenerateKey(<length>, "<key>");
uint ret   = Randomizer.GenerateUInt("<key>");
byte[] ret = Randomizer.GenerateBytes(<length>, "<key>");

Rastgele bir sayıya sahip olmak için aşağıdaki kodu kullandım (önerilmez):

var random = new Random((int)DateTime.Now.Ticks);
var randomValue = random.Next(startValue, endValue + 1);

Bu iyi olsa da:

Random random = new Random();
int randomNumber = random.Next()

Çoğu zaman limiti kontrol etmek istersiniz (min ve maks. Mumbers). Bu yüzden rastgele sayının nerede başlayıp biteceğini belirtmeniz gerekir.

Next()Yöntemi, iki parametre, minimum ve maksimum kabul eder.

Eğer rastgele sayımın 5 ile 15 arasında olmasını istersem,

int randomNumber = random.Next(5, 16)

Kullandığım sınıf bu. Gibi çalışırRandomNumber.GenerateRandom(1, 666)

internal static class RandomNumber
{
    private static Random r = new Random();
    private static object l = new object();
    private static Random globalRandom = new Random();
    [ThreadStatic]
    private static Random localRandom;
    public static int GenerateNewRandom(int min, int max)
    {
        return new Random().Next(min, max);
    }
    public static int GenerateLockedRandom(int min, int max)
    {
        int result;
        lock (RandomNumber.l)
        {
            result = RandomNumber.r.Next(min, max);
        }
        return result;
    }
    public static int GenerateRandom(int min, int max)
    {
        Random random = RandomNumber.localRandom;
        if (random == null)
        {
            int seed;
            lock (RandomNumber.globalRandom)
            {
                seed = RandomNumber.globalRandom.Next();
            }
            random = (RandomNumber.localRandom = new Random(seed));
        }
        return random.Next(min, max);
    }
}

Her seferinde yeni bir rastgele jeneratör kullanıldığında ne olduğunu göstermek istedim. Her biri rastgele bir sayı gerektiren iki yönteminiz veya iki sınıfınız olduğunu varsayalım. Ve safça onları şöyle kodlarsınız:

public class A
{
    public A()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}

İki farklı kimlik kazanacağınızı düşünüyor musunuz? HAYIR

class Program
{
    static void Main(string[] args)
    {
        A a=new A();
        B b=new B();

        int ida=a.ID, idb=b.ID;
        // ida = 1452879101
        // idb = 1452879101
    }
}

Çözüm her zaman tek bir statik rastgele jeneratör kullanmaktır. Bunun gibi:

public static class Utils
{
    public static readonly Random random=new Random();
}

public class A
{
    public A()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}

Güçlü rastgele tohumlar için zaman değil, daima CryptoRNG kullanıyorum.

using System;
using System.Security.Cryptography;

public class Program
{
    public static void Main()
    {
        var random = new Random(GetSeed());
        Console.WriteLine(random.Next());
    }

    public static int GetSeed() 
    {
        using (var rng = new RNGCryptoServiceProvider())
        {
            var intBytes = new byte[4];
            rng.GetBytes(intBytes);
            return BitConverter.ToInt32(intBytes, 0);
        }
    }
}

Random random = new Random ();
int randomNumber = random.Next (lowerBound,upperBound);

Gelecekte referans olması için bir not gibi.

.NET Core kullanıyorsanız, birden çok Rastgele örnek eskisi kadar tehlikeli değildir. Bu sorunun 2010'dan geldiğinin farkındayım, ancak bu soru eski ama bazı çekiciliği olduğundan, değişikliği belgelemek iyi bir şey olduğunu düşünüyorum.

Bir süre önce yaptığım bu soruya başvurabilirsiniz:

Microsoft, Rastgele varsayılan çekirdeği değiştirdi mi?

Temel olarak, varsayılan çekirdeği olarak Environment.TickCountdeğiştirdiler Guid.NewGuid().GetHashCode(), bu nedenle 2 Rastgele örnek oluşturursanız aynı sayıları görüntülemez.

.NET Framework / .NET Core'dan (2.0.0+) gelen diffs dosyasını burada görebilirsiniz: https://github.com/dotnet/coreclr/pull/2192/commits/9f6a0b675e5ac0065a268554de49162c539ff66d

RNGCryptoServiceProvider kadar güvenli değil, ama en azından size garip sonuçlar vermeyecek.

Bir bilgisayar tarafından deterministik bir süreçle hesaplanan sayılar, tanım gereği rastgele olamaz.

Gerçek bir rasgele sayılar istiyorsanız, rasgelelik atmosferik gürültü veya radyoaktif bozunmadan kaynaklanır.

Örneğin RANDOM.ORG'u deneyebilirsiniz (performansı düşürür)

Random rand = new Random();
int name = rand.Next()

İstediğiniz değerleri ikinci parantez içine koyun, kodu oluşturmak için prop ve çift sekme yazarak bir ad ayarladığınızdan emin olun.

Bir CSRNG'nin bir min ve maks arasında rasgele sayılar üretmesini istiyorsanız, bu tam size göre. RandomGüvenli rastgele tohumlarla sınıfları başlatacaktır .

    class SecureRandom : Random
    {
        public static byte[] GetBytes(ulong length)
        {
            RNGCryptoServiceProvider RNG = new RNGCryptoServiceProvider();
            byte[] bytes = new byte[length];
            RNG.GetBytes(bytes);
            RNG.Dispose();
            return bytes;
        }
        public SecureRandom() : base(BitConverter.ToInt32(GetBytes(4), 0))
        {

        }
        public int GetRandomInt(int min, int max)
        {
            int treashold = max - min;
            if(treashold != Math.Abs(treashold))
            {
                throw new ArithmeticException("The minimum value can't exceed the maximum value!");
            }
            if (treashold == 0)
            {
                throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
            }
            return min + (Next() % treashold);
        }
        public static int GetRandomIntStatic(int min, int max)
        {
            int treashold = max - min;
            if (treashold != Math.Abs(treashold))
            {
                throw new ArithmeticException("The minimum value can't exceed the maximum value!");
            }
            if(treashold == 0)
            {
                throw new ArithmeticException("The minimum value can't be the same as the maximum value!");
            }
            return min + (BitConverter.ToInt32(GetBytes(4), 0) % treashold);
        }
    }

Üzgünüz, OP gerçekten rastgele bir intdeğer gerektirir , ancak rastgele bir BigIntegerdeğer istiyorsanız basit bir bilgi paylaşmak için aşağıdaki ifadeyi kullanabilirsiniz:

BigInteger randomVal = BigInteger.Abs(BigInteger.Parse(Guid.NewGuid().ToString().Replace("-",""), NumberStyles.AllowHexSpecifier));

Aşağıdaki gibi düzgün dağıtılmış rasgele sayı üreteci istediğinizi varsayacağım. C # ve C ++ dahil olmak üzere programlama dilinin çoğunda rastgele sayı kullanılmadan önce karıştırılmaz. Bu, aynı sayıyı tekrar tekrar alacağınız anlamına gelir, bu gerçekten rastgele değildir. Aynı sayıyı tekrar tekrar çizmekten kaçınmak için bir tohuma ihtiyacınız vardır. Tipik olarak, zaman içindeki keneler bu görev için uygundur. Her seferinde aynı tohumu kullanıyorsanız aynı numarayı tekrar tekrar alacağınızı unutmayın. Bu yüzden her zaman değişen tohumları kullanmaya çalışın. Zaman tohum için iyi bir kaynaktır çünkü her zaman kovalarlar.

int GetRandomNumber(int min, int max)
{
    Random rand = new Random((int)DateTime.Now.Ticks);
    return rand.Next(min, max);
}

Normal dağılım için rasgele sayı üreteci arıyorsanız, bir Box-Muller dönüşümü kullanabilirsiniz. Rastgele Gauss Değişkeni Sorusunda yoyoyoyosef'in cevabını kontrol edin. Tamsayı istediğiniz için, tamsayıya çift değer atamanız gerekir.

Random rand = new Random(); //reuse this if you are generating many
double u1 = 1.0-rand.NextDouble(); //uniform(0,1] random doubles
double u2 = 1.0-rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
         Math.Sin(2.0 * Math.PI * u2); //random normal(0,1)
double randNormal =
         mean + stdDev * randStdNormal; //random normal(mean,stdDev^2)

Rastgele Gauss Değişkenleri

En kolay yol muhtemelen sadece Random.range(1, 3)Bu 1 ve 2 arasında bir sayı üretecektir.

Aşağıdakileri kullanarak rastgele tohum değeri ile deneyebilirsiniz:

var rnd = new Random(11111111); //note: seed value is 11111111

string randomDigits = rnd.Next();

var requestNumber = $"SD-{randomDigits}";

Neden kullanmıyorsunuz int randomNumber = Random.Range(start_range, end_range)?

Rastgele bir örneği tekrar tekrar kullanma

// Somewhat better code...
Random rng = new Random();
for (int i = 0; i < 100; i++)
{
    Console.WriteLine(GenerateDigit(rng));
}
...
static int GenerateDigit(Random rng)
{
    // Assume there'd be more logic here really
    return rng.Next(10);
}

Bu makalede, rasgeleliğin neden bu kadar çok soruna neden olduğu ve bunların nasıl ele alınacağı ele alınmaktadır. http://csharpindepth.com/Articles/Chapter12/Random.aspx

Rasgele sayılar oluşturmak için şu basit adımları deneyin:

Oluşturma işlevi:

private int randomnumber(int min, int max)
{
    Random rnum = new Random();
    return rnum.Next(min, max);
}

Yukarıdaki işlevi rastgele sayılar kullanmak istediğiniz bir yerde kullanın. Bir metin kutusunda kullanmak istediğinizi varsayalım.

textBox1.Text = randomnumber(0, 999).ToString();

0 min ve 999 max. Değerleri istediğiniz gibi değiştirebilirsiniz.

Her zaman çeşitli amaçlar için yardımcı rastgele sayılar üreten yöntemleri var. Umarım bu da size yardımcı olabilir:

public class RandomGenerator  
{  
    public int RandomNumber(int min, int max)  
    {  
        var random = new Random();  
        return random.Next(min, max);  
    }  

    public string RandomString(int size, bool lowerCase)  
    {  
        var builder = new StringBuilder();  
        var random  = new Random();  
        char ch;  

        for (int i = 0; i < size; i++)  
        {  
            ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65)));  
            builder.Append(ch);  
        }  

        if (lowerCase)  
            return builder.ToString().ToLower();  
        return builder.ToString();  
    }  
}

Satır içi için hızlı ve kolay, aşağıdaki kodu kullanın:

new Random().Next(min, max);

// for example unique name
strName += "_" + new Random().Next(100, 999);