Sadece bir rastgele sayı üreten rastgele sayı üreteci

Ben aşağıdaki işlevi var:

//Function to get random number
public static int RandomNumber(int min, int max)
{
    Random random = new Random();
    return random.Next(min, max);
}

Nasıl diyorum:

byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
    mac[x] = (byte)(Misc.RandomNumber((int)0xFFFF, (int)0xFFFFFF) % 256);

Ben çalışma sırasında hata ayıklayıcı ile bu döngü adım (Ben istediğim budur) farklı değerler olsun. Ancak, bu kodun altına iki satır kesme noktası koyarsam, macdizinin tüm üyeleri eşit değere sahiptir.

Bu neden oluyor?

Her yaptığınızda new Random()saat kullanılarak 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 tutmalı Rastgele örneği ve kullanmaya devam İleri üzerinde aynı örneği.

//Function to get a random number 
private static readonly Random random = new Random(); 
private static readonly object syncLock = new object(); 
public static int RandomNumber(int min, int max)
{
    lock(syncLock) { // synchronize
        return random.Next(min, max);
    }
}

Düzenleme (yorumlara bakın): neden lockburaya ihtiyacımız var?

Temel olarak, örneğin Nextiç durumunu değiştirecektir Random. Biz birden çok iş parçacığı aynı anda o yaparsanız olabilir iddia "Biz sadece sonuç daha rastgele yaptık" ama ne biz edilir aslında potansiyel olarak iç uygulanmasını kırılıyor yapıyor ve biz de aynı numaraları almak başlayabileceğini farklı iplikler, gelen olabilir ve olmayabilir - bir sorun. Bununla birlikte, dahili olarak ne olacağının garantisi daha büyük bir sorundur; çünkü Randomyok değil parçacığı güvenliği hiçbir garanti. Dolayısıyla iki geçerli yaklaşım vardır:

• Farklı iş parçacıklarından aynı anda erişmemiz için senkronize edin
• RandomHer iş parçacığı için farklı örnekler kullanın

Her ikisi de iyi olabilir; ancak aynı anda birden çok arayandan gelen tek bir örneği kesmek , sadece sorun istemektir.

lockBu yaklaşımların birinci (ve daha basit) ulaşır; ancak, başka bir yaklaşım şöyle olabilir:

private static readonly ThreadLocal<Random> appRandom
     = new ThreadLocal<Random>(() => new Random());

bu iş parçacığı başına yapılır, bu nedenle senkronize etmeniz gerekmez.

Uygulamanız boyunca yeniden kullanım kolaylığı için statik bir sınıf yardımcı olabilir.

public static class StaticRandom
{
    private static int seed;

    private static ThreadLocal<Random> threadLocal = new ThreadLocal<Random>
        (() => new Random(Interlocked.Increment(ref seed)));

    static StaticRandom()
    {
        seed = Environment.TickCount;
    }

    public static Random Instance { get { return threadLocal.Value; } }
}

Daha sonra aşağıdaki gibi kodla statik rasgele örneği kullanabilirsiniz

StaticRandom.Instance.Next(1, 100);

Mark'ın çözümü her zaman senkronize edilmesi gerektiğinden oldukça pahalı olabilir.

İş parçacığına özgü depolama desenini kullanarak senkronizasyon ihtiyacını karşılayabiliriz:

public class RandomNumber : IRandomNumber
{
    private static readonly Random Global = new Random();
    [ThreadStatic] private static Random _local;

    public int Next(int max)
    {
        var localBuffer = _local;
        if (localBuffer == null) 
        {
            int seed;
            lock(Global) seed = Global.Next();
            localBuffer = new Random(seed);
            _local = localBuffer;
        }
        return localBuffer.Next(max);
    }
}

İki uygulamayı ölçün ve önemli bir fark görmelisiniz.

Buradan cevabım :

Sadece doğru çözümü tekrarlamak :

namespace mySpace
{
    public static class Util
    {
        private static rnd = new Random();
        public static int GetRandom()
        {
            return rnd.Next();
        }
    }
}

Böylece şunları arayabilirsiniz:

var i = Util.GetRandom();

Her yerinde.

Rastgele sayılar üretmek için kesinlikle gerçek bir durumsuz statik yönteme ihtiyacınız varsa , a Guid.

public static class Util
{
    public static int GetRandom()
    {
        return Guid.NewGuid().GetHashCode();
    }
}

Bir wee biraz daha yavaş olacak, ama çok daha rastgele olabilir daha Random.Nextaz deneyimlerime.

Ama değil :

new Random(Guid.NewGuid().GetHashCode()).Next();

Gereksiz nesne oluşturma, özellikle bir döngü altında onu yavaşlatacaktır.

Ve asla :

new Random().Next();

Sadece yavaş değil (bir döngü içinde), rastgele ... bana göre gerçekten iyi değil ..

Rastgele sayılar üretmek için aşağıdaki sınıfı kullanmayı tercih ederim:

byte[] random;
System.Security.Cryptography.RNGCryptoServiceProvider prov = new System.Security.Cryptography.RNGCryptoServiceProvider();
prov.GetBytes(random);

1) Marc Gravell'in dediği gibi, BİR rasgele jeneratör kullanmaya çalışın. Bunu yapıcıya eklemek her zaman iyidir: System.Environment.TickCount.

2) Bir ipucu. Diyelim ki 100 nesne oluşturmak ve her birinin kendi rastgele oluşturucusuna sahip olması gerektiğini varsayalım (çok kısa sürede rastgele sayıların YÜKLERİNİ hesaplarsanız kullanışlıdır). Bunu bir döngüde (100 nesne oluşturma) yaparsanız, bunu (tam rastgele olmayı sağlamak için) şu şekilde yapabilirsiniz:

int inMyRandSeed;

for(int i=0;i<100;i++)
{
   inMyRandSeed = System.Environment.TickCount + i;
   .
   .
   .
   myNewObject = new MyNewObject(inMyRandSeed);  
   .
   .
   .
}

// Usage: Random m_rndGen = new Random(inMyRandSeed);

Şerefe.

Her yürüttüğünüzde

Random random = new Random (15);

Milyonlarca kez çalıştırmanız önemli değil, her zaman aynı tohumu kullanacaksınız.

Eğer kullanırsan

Random random = new Random ();

Bir bilgisayar korsanı tohumu tahmin ederse ve algoritmanız sisteminizin güvenliği ile ilgiliyse farklı rasgele sayı dizileri elde edersiniz - algoritmanız bozulur. Ben mult yürütüyorum. Bu kurucuda tohum, sistem saati ile belirtilir ve çok kısa bir sürede (milisaniye) birkaç örnek oluşturulursa, aynı tohuma sahip olmaları mümkündür.

Güvenli rasgele sayılara ihtiyacınız varsa sınıfı kullanmalısınız

System.Security.Cryptography.RNGCryptoServiceProvider

public static int Next(int min, int max)
{
    if(min >= max)
    {
        throw new ArgumentException("Min value is greater or equals than Max value.");
    }
    byte[] intBytes = new byte[4];
    using(RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
    {
        rng.GetNonZeroBytes(intBytes);
    }
    return  min +  Math.Abs(BitConverter.ToInt32(intBytes, 0)) % (max - min + 1);
}

Kullanımı:

int randomNumber = Next(1,100);

Rastgele sınıf değişkenini şöyle bildirmeniz yeterlidir:

    Random r = new Random();
    // ... Get three random numbers.
    //     Here you'll get numbers from 5 to 9
    Console.WriteLine(r.Next(5, 10));

listenizden her seferinde farklı rastgele numaralar almak istiyorsanız

r.Next(StartPoint,EndPoint) //Here end point will not be included

Her seferinde bir Random r = new Random()kez beyan ederek .

Burada bir çok çözüm var: sadece sayıları silmek istiyorsanız harfleri silin ve yöntem rastgele ve sonuç uzunluğunu alır.

public String GenerateRandom(Random oRandom, int iLongitudPin)
{
    String sCharacters = "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ123456789";
    int iLength = sCharacters.Length;
    char cCharacter;
    int iLongitudNuevaCadena = iLongitudPin; 
    String sRandomResult = "";
    for (int i = 0; i < iLongitudNuevaCadena; i++)
    {
        cCharacter = sCharacters[oRandom.Next(iLength)];
        sRandomResult += cCharacter.ToString();
    }
    return (sRandomResult);
}