unity Wie erzeuge ich eine zufällige int-Nummer in C#?




unity random number (18)

Wie generiere ich eine zufällige Ganzzahl in C #?


Die Random Klasse wird zum Erstellen von Zufallszahlen verwendet. (Pseudozufällig, das ist natürlich.).

Beispiel:

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

Wenn Sie mehr als eine Zufallszahl erstellen möchten, sollten Sie die Random beibehalten und sie erneut verwenden. Wenn Sie neue Instanzen zu nah an der Zeit erstellen, werden sie die gleiche Reihe von Zufallszahlen erzeugen, wie der Zufallsgenerator aus der Systemuhr gesetzt wird.


Jedes Mal, wenn Sie neu Random () tun, wird es initialisiert. Dies bedeutet, dass Sie in einer engen Schleife oft den gleichen Wert erhalten. Sie sollten eine einzelne Random-Instanz beibehalten und Next weiterhin für dieselbe Instanz verwenden.

//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);
    }
}

Warum nicht int randomNumber = Random.Range(start_range, end_range) ?


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

Sie können versuchen, mit zufälligen Startwert unter Verwendung von:

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

string randomDigits = rnd.Next().ToString().Substring(0, 8);

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

Beachten Sie, dass new Random() auf dem aktuellen Zeitstempel gesetzt wird.

Wenn Sie nur eine Nummer generieren möchten, können Sie Folgendes verwenden:

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

Weitere Informationen finden Sie in der Random Klasse. Beachten Sie jedoch Folgendes:

Da die Uhr jedoch über eine begrenzte Auflösung verfügt, werden mit dem parameterlosen Konstruktor Zufallszahlengeneratoren erzeugt, die identische Folgen von Zufallszahlen erzeugen

Verwenden Sie diesen Code nicht, um eine Zufallszahl zu generieren.


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

Sie können der Funktion Next() auch einen minimalen und einen maximalen Wert Next() . Mögen

 int n = new Random().Next(5,10);

Ich wollte demonstrieren, was passiert, wenn jedes Mal ein neuer Zufallsgenerator verwendet wird. Angenommen, Sie haben zwei Methoden oder zwei Klassen, die jeweils eine Zufallszahl erfordern. Und naiv du codierst sie wie:

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; }
}

Glaubst du, du bekommst zwei verschiedene IDs? NEE

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
    }
}

Die Lösung besteht darin, immer einen einzigen statischen Zufallsgenerator zu verwenden. So was:

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; }
}

Ich verwende den folgenden Code, um eine Zufallszahl zu haben:

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

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

Ich habe alle diese Lösungen ausprobiert, ausschließlich der COBOL-Antwort ... lol

Keine dieser Lösungen war gut genug. Ich brauchte Randoms in einer Fast-for-Int-Schleife und ich bekam Tonnen von doppelten Werten sogar in sehr weiten Bereichen. Nachdem ich mich viel zu lange für zufällige Ergebnisse entschieden hatte, beschloss ich, dieses Problem endlich ein für allemal anzugehen.

Es geht nur um den Samen.

Ich erstelle eine zufällige Ganzzahl, indem ich die Nicht-Ziffern von Guid analysiere, dann benutze ich das, um meine Random-Klasse zu instantiieren.

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);
}

Update : Seeding ist nicht notwendig, wenn Sie die Random-Klasse einmal instanziieren. Daher wäre es am besten, eine statische Klasse zu erstellen und eine Methode aufzurufen.

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);
   }
}

Dann können Sie die statische Klasse wie folgt verwenden ..

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

Ich gebe zu, ich mag diesen Ansatz besser.


Die von der eingebauten Random Klasse (System.Random) generierten Zahlen erzeugen Pseudozufallszahlen.

Wenn Sie echte Zufallszahlen wollen, ist der sicherste Pseudo-Zufallsgenerator der sicherste, den Sie erhalten können, indem Sie die kryptografischen Klassen in C # wie RNGCryptoServiceProvider .

Wenn Sie jedoch immer noch echte Zufallszahlen benötigen, müssen Sie eine externe Quelle verwenden, z. B. Geräte, die den radioaktiven Zerfall als Ausgangspunkt für einen Zufallsgenerator berücksichtigen. Da per definitionem jede durch rein algorithmische Mittel erzeugte Zahl nicht wirklich zufällig sein kann.


Es ist besser, das Random-Objekt mit den aktuellen Millisekunden zu setzen, um eine echte Zufallszahl sicherzustellen, und Sie werden Dubletten fast nicht mehr häufig finden

Random rand = new Random(DateTime.Now.Millisecond);

Dies ist die Klasse, die ich verwende. Funktioniert wie RandomNumber.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);
    }
}

Sie könnten Jon StaticRandom Methode in der MiscUtil-Klassenbibliothek verwenden, die er für eine Pseudozufallszahl erstellt hat.

using System;
using MiscUtil;

class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine(StaticRandom.Next());
        }
    }
}

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

Setzen Sie die gewünschten Werte in die zweiten Klammern. Stellen Sie sicher, dass Sie einen Namen festgelegt haben, indem Sie Prop und Double Tab schreiben, um den Code zu generieren


Die Frage sieht sehr einfach aus, aber die Antwort ist etwas kompliziert. Wenn Sie sehen, hat fast jeder vorgeschlagen, die Random-Klasse zu verwenden, und einige haben vorgeschlagen, die RNG-Crypto-Klasse zu verwenden. Aber dann wann, was zu wählen.

Dafür müssen wir zunächst den Begriff RANDOMNESS und die dahinter stehende Philosophie verstehen.

Ich möchte Sie ermutigen, dieses Video anzuschauen, das in der Philosophie von RANDOMNESS mit C # https://www.youtube.com/watch?v=tCYxc-2-3fY vertieft

Als erstes sollten wir die Philosophie der ZUFÄLLIGKEIT verstehen. Wenn wir einer Person sagen, dass sie zwischen ROT, GRÜN und GELB wählen soll, was intern geschieht. Was bewirkt, dass eine Person ROT oder GELB oder GRÜN wählt?

Ein erster Gedanke geht in den Verstand der Personen, der seine Wahl entscheidet, es kann Lieblingsfarbe, glückliche Farbe und so weiter sein. Mit anderen Worten, ein Anfangstrigger, den wir in RANDOM als SEED bezeichnen. Dieser SEED ist der Anfangspunkt, der Trigger, der ihn dazu bringt, den RANDOM-Wert zu wählen.

Wenn nun ein SEED leicht zu erraten ist, werden diese Art von Zufallszahlen als PSEUDO bezeichnet, und wenn ein Seed schwer zu erraten ist, werden diese Zufallszahlen als SECURED- Zufallszahlen bezeichnet.

Zum Beispiel wählt eine Person die Farbe abhängig von Wetter und Klangkombination, dann wäre es schwierig, den Anfangssamen zu erraten.

Lassen Sie mich nun eine wichtige Aussage machen:

* "Random" -Klasse erzeugt nur PSEUDO-Zufallszahl und um SECURE-Zufallszahl zu generieren, müssen wir die "RNGCryptoServiceProvider" -Klasse verwenden.

Die Random-Klasse nimmt Startwerte aus Ihrer CPU-Uhr, die sehr vorhersehbar sind. Mit anderen Worten erzeugt die RANDOM-Klasse von C # Pseudozufallszahlen, darunter ist der Code für dieselbe.

Random rnd= new Random();
int rndnumber = rnd.Next()

Während die RNGCryptoServiceProvider-Klasse OS-Entropie verwendet, um Seeds zu generieren. Die OS-Entropie ist ein zufälliger Wert, der unter Verwendung von Sound-, Mausklick- und Tastatur-Timings, thermischen Temp usw. erzeugt wird. Unten folgt der Code für denselben.

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

Um die OS-Entropie zu verstehen, siehe dieses Video https://www.youtube.com/watch?v=tCYxc-2-3fY von 11:20, wo die Logik der OS-Entropie erklärt wird. Mit einfachen Worten erzeugt RNG Crypto sichere Zufallszahlen.


Ich wollte eine kryptografisch sichere Version hinzufügen:

RNGCryptoServiceProvider-Klasse ( MSDN oder dotnetperls )

Es implementiert IDisposable.

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




random