අහඹු int අංකයක් ජනනය කරන්නේ කෙසේද?

C # හි අහඹු පූර්ණ සංඛ්‍යාවක් ජනනය කරන්නේ කෙසේද?

මෙම Randomපන්ති අහඹු සංඛ්යා නිර්මාණය කිරීමට භාවිතා වේ. (ඇත්ත වශයෙන්ම ව්‍යාජ සසම්භාවී.).

උදාහරණයක්:

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

ඔබ අහඹු අංක එකකට වඩා සෑදීමට යන්නේ නම්, ඔබ එම Randomඅවස්ථාව තබාගෙන එය නැවත භාවිතා කළ යුතුය. ඔබ කාලයාගේ ඇවෑමෙන් නව අවස්ථා නිර්මාණය කරන්නේ නම්, අහඹු උත්පාදක යන්ත්රය පද්ධති ඔරලෝසුවෙන් බීජ ලබා ගන්නා විට ඒවා අහඹු සංඛ්‍යා මාලාවක් නිපදවනු ඇත.

ප්‍රශ්නය ඉතා සරල බව පෙනේ, නමුත් පිළිතුර ටිකක් සංකීර්ණයි. ඔබ දුටුවහොත් සෑම කෙනෙක්ම පාහේ සසම්භාවී පන්තිය භාවිතා කිරීමට යෝජනා කර ඇති අතර සමහරු RNG ක්‍රිප්ටෝ පන්තිය භාවිතා කිරීමට යෝජනා කර ඇත. නමුත් පසුව තෝරාගත යුත්තේ කුමක්ද.

ඒ සඳහා අප මුලින්ම RANDOMNESS යන පදය සහ එය පිටුපස ඇති දර්ශනය තේරුම් ගත යුතුය.

C # https://www.youtube.com/watch?v=tCYxc-2-3fY භාවිතා කරමින් RANDOMNESS දර්ශනයේ ගැඹුරින් ගැඹුරට යන මෙම වීඩියෝව නැරඹීමට මම ඔබව දිරිමත් කරමි.

පළමුවෙන්ම අපි අහඹු දර්ශනය තේරුම් ගනිමු. RED, GREEN සහ YELLOW අතර තෝරා ගැනීමට අපි පුද්ගලයෙකුට පැවසූ විට අභ්‍යන්තරව සිදුවන්නේ කුමක්ද. පුද්ගලයෙකුට රතු හෝ යෙලෝ හෝ හරිත තෝරා ගැනීමට හේතුව කුමක්ද?

ඔහුගේ තේරීම තීරණය කරන පුද්ගල මනස තුළට සමහර ආරම්භක සිතුවිලි ගමන් කරයි, එය ප්‍රියතම වර්ණය, වාසනාවන්ත වර්ණය සහ යනාදිය විය හැකිය. වෙනත් වචන වලින් කිවහොත්, අපි RANDOM හි SEED ලෙස හඳුන්වන ආරම්භක ප්‍රේරකයකි. මෙම SEED යනු ආරම්භක ලක්ෂ්‍යය වන අතර, RANDOM අගය තෝරා ගැනීමට ඔහුව පොළඹවයි.

දැන් බීජයක් අනුමාන කිරීම පහසු නම්, එම වර්ගයේ අහඹු සංඛ්‍යා PSEUDO ලෙස හඳුන්වනු ලබන අතර බීජයක් අනුමාන කිරීම දුෂ්කර වූ විට එම අහඹු සංඛ්‍යා සුරක්‍ෂිත අහඹු සංඛ්‍යා ලෙස හැඳින්වේ .

උදාහරණයක් ලෙස පුද්ගලයෙකු තෝරා ගන්නේ කාලගුණය සහ ශබ්ද සංයෝජනය අනුව වර්ණයයි, එවිට ආරම්භක බීජය අනුමාන කිරීම දුෂ්කර වනු ඇත.

දැන් මට වැදගත් ප්‍රකාශයක් කිරීමට ඉඩ දෙන්න: -

* “සසම්භාවී” පන්තිය ජනනය කරන්නේ PSEUDO සසම්භාවී අංකය පමණක් වන අතර සුරක්ෂිත අහඹු අංකයක් ජනනය කිරීම සඳහා “RNGCryptoServiceProvider” පන්තිය භාවිතා කළ යුතුය.

සසම්භාවී පන්තිය ඔබේ CPU ඔරලෝසුවෙන් බීජ අගයන් ලබා ගනී. එබැවින් වෙනත් වචන වලින් කිවහොත්, C # හි RANDOM පන්තිය ව්‍යාජ සසම්භාවී සංඛ්‍යා ජනනය කරයි, ඒ සඳහා කේතය පහත දැක්වේ.

** සටහන: ** .NET Core 2.0.0+පරාමිති රහිත ඉදිකිරීම්කරු මත වෙනස් බීජයක් භාවිතා කරයි : එය භාවිතා කරන CPU ඔරලෝසුව වෙනුවට Guid.NewGuid().GetHashCode().

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

කරන අතර RNGCryptoServiceProviderපන්ති බීජ උත්පාදනය කිරීමට මෙහෙයුම් පද්ධතිය එන්ට්රොපිය භාවිතා කරයි. ඕඑස් එන්ට්‍රොපි යනු අහඹු අගයක් වන අතර එය ශබ්දය, මූසික ක්ලික් කිරීම සහ යතුරුපුවරු වේලාවන්, තාප තාවකාලික යනාදිය භාවිතයෙන් ජනනය වේ.

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

OS එන්ට්‍රොපිය අවබෝධ කර ගැනීම සඳහා මෙම වීඩියෝව 14:30 සිට බලන්න https://www.youtube.com/watch?v=tCYxc-2-3fY එහිදී OS එන්ට්‍රොපියේ තර්කනය පැහැදිලි කර ඇත. එබැවින් සරල වචන වලින් ආර්එන්ජී ක්‍රිප්ටෝ සුරක්ෂිත අහඹු සංඛ්‍යා ජනනය කරයි.

ඔබ නව සසම්භාවී () කරන සෑම අවස්ථාවකම එය ආරම්භ කරනු ලැබේ. මෙයින් අදහස් කරන්නේ තද පුඩුවක් තුළ ඔබට එකම අගය බොහෝ වාරයක් ලැබෙන බවයි. ඔබ තනි අහඹු අවස්ථාවක් තබාගෙන එකම අවස්ථාවෙහිදී Next භාවිතා කළ යුතුය.

//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()වත්මන් කාලරාමුව මත බීජ ඇති බව පරෙස්සම් වන්න .

ඔබට එක් අංකයක් පමණක් ජනනය කිරීමට අවශ්‍ය නම් ඔබට භාවිතා කළ හැකිය:

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

වැඩි විස්තර සඳහා, අහඹු පංතිය දෙස බලන්න , කරුණාකර සටහන් කරන්න:

කෙසේ වෙතත්, ඔරලෝසුවට සීමිත විභේදනයක් ඇති හෙයින්, පරාමිති රහිත ඉදිකිරීම්කරු භාවිතා කරමින් විවිධ සසම්භාවී වස්තූන් සමීපව නිර්මාණය කිරීම සඳහා අහඹු සංඛ්‍යා උත්පාදක යන්ත්‍ර නිර්මාණය කරයි.

එබැවින් අහඹු සංඛ්‍යා මාලාවක් ජනනය කිරීමට මෙම කේතය භාවිතා නොකරන්න.

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

ගුප්ත විද්‍යාත්මකව ආරක්ෂිත අනුවාදයක් එක් කිරීමට මට අවශ්‍ය විය:

RNGCryptoServiceProvider Class ( MSDN හෝ dotnetperls )

එය හඳුනාගත නොහැකි ලෙස ක්‍රියාත්මක කරයි.

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

ව්‍යාජ අහඹු අංකයක් සඳහා ඔහු විසින් සාදන ලද මිස්කූටිල් පන්ති පුස්තකාලය තුළ ඔබට ජෝන් ස්කීට්ගේ ස්ථිතික රැන්ඩම් ක්‍රමය භාවිතා කළ හැකිය .

using MiscUtil;
...

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

COBOL පිළිතුර හැර මම මේ සියලු විසඳුම් අත්හදා බැලුවෙමි ... lol

මෙම විසඳුම් කිසිවක් ප්‍රමාණවත් නොවීය. මට ඉන්ටර් ලූප් සඳහා වේගයෙන් අහඹු ලෙස අවශ්‍ය වූ අතර ඉතා පුළුල් පරාසයක වුවද මට අනුපිටපත් ටොන් ගණනක් ලැබුණි. අහඹු ලෙස ප්‍රති results ල ලබා ගැනීම සඳහා බොහෝ කාලයක් ගත වූ පසු මම තීරණය කළේ මෙම ගැටලුව එකවරම විසඳා ගැනීමටයි.

ඒ සියල්ල බීජය ගැන ය.

මාර්ගෝපදේශයෙන් ඉලක්කම් නොවන කොටස් විග්‍රහ කිරීමෙන් මම අහඹු පූර්ණ සංඛ්‍යාවක් නිර්මාණය කරමි, පසුව මගේ අහඹු පන්තිය ක්ෂණිකව දැක්වීමට මම එය භාවිතා කරමි.

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

යාවත්කාලීන කිරීම : ඔබ සසම්භාවී පංතිය එක් වරක් ක්ෂණිකව කළහොත් බීජ පැළ කිරීම අවශ්‍ය නොවේ. එබැවින් ස්ථිතික පංතියක් නිර්මාණය කර එය ඉවත් කිරීමේ ක්‍රමයක් කැඳවීම වඩාත් සුදුසුය.

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

එවිට ඔබට ස්ථිතික පන්තිය භාවිතා කළ හැකිය ..

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

මම පිළිගන්නවා මම මේ ප්‍රවේශයට වඩා කැමතියි.

සසම්භාවී වස්තුවක් සාදන්න

Random rand = new Random();

එය භාවිතා කරන්න

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

ඔබට new Random()සසම්භාවී අංකයක් අවශ්‍ය සෑම අවස්ථාවකම ආරම්භ කිරීමට අවශ්‍ය නැත , එක් අහඹු ලෙස ආරම්භ කර ඔබට අවශ්‍ය වාර ගණනක් ලූපයක් තුළ හෝ වෙනත් ඕනෑම දෙයක් භාවිතා කරන්න

මෙම සුරකින විසින් ජනනය කරන ලද සංඛ්යා Randomපන්ති (System.Random) ව්යාජ අහඹු ලෙස.

ඔබට සත්‍ය සසම්භාවී සංඛ්‍යා අවශ්‍ය නම්, අපට ලබා ගත හැකි ආසන්නම ස්ථානය වන්නේ “ආරක්ෂිත ව්‍යාජ සසම්භාවී උත්පාදක යන්ත්රය” වන අතර එය C # හි ගුප්ත ලේඛන පංති භාවිතා කිරීමෙන් ජනනය කළ හැකිය RNGCryptoServiceProvider.

එසේ වුවද, ඔබට තවමත් සත්‍ය අහඹු සංඛ්‍යා අවශ්‍ය නම්, අහඹු සංඛ්‍යා උත්පාදක යන්ත්‍රයක් සඳහා බීජයක් ලෙස විකිරණශීලී ක්ෂය වීම සඳහා ගණනය කරන උපාංග වැනි බාහිර ප්‍රභවයක් භාවිතා කිරීමට ඔබට අවශ්‍ය වනු ඇත. නිර්වචනය අනුව, තනිකරම ඇල්ගොරිතම මාධ්‍යයන් මගින් ජනනය කරන ඕනෑම සංඛ්‍යාවක් සැබවින්ම අහඹු විය නොහැක.

වෙනස් කළ පිළිතුර මෙතැනින් .

ඔබට Intel Secure Key අනුකූල CPU වෙත ප්‍රවේශය ඇත්නම්, ඔබට මෙම පුස්තකාල භාවිතා කර සැබෑ අහඹු සංඛ්‍යා සහ නූල් ජනනය කළ හැකිය: https://github.com/JebteK/RdRand සහ https://www.rdrand.com/

නවතම අනුවාදය මෙතැනින් බාගත කරන්න , ජෙබ්ටෙක්.ආර්.ඩ්‍රෑන්ඩ් ඇතුළත් කර ඒ සඳහා භාවිතා කරන ප්‍රකාශයක් එක් කරන්න. එවිට, ඔබ කළ යුත්තේ මෙයයි:

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

කේතය ක්‍රියාත්මක කිරීමට ඔබට අනුකූල CPU නොමැති නම්, rdrand.com හි RESTful සේවාවන් භාවිතා කරන්න. ඔබේ ව්‍යාපෘතියට RdRandom එතුම පුස්තකාලය ඇතුළත් කර ඇති විට, ඔබට මෙය කිරීමට අවශ්‍ය වනු ඇත (ඔබ ලියාපදිංචි වූ විට ඔබට නොමිලේ ඇමතුම් 1000 ක් ලැබෙනු ඇත):

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

අහඹු අංකයක් ලබා ගැනීමට මම පහත කේතය භාවිතා කළෙමි (නිර්දේශ කර නැත):

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

මෙය හරි අතර:

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

ඔබට බොහෝ විට සීමාව (අවම සහ උපරිම මැම්බර්) පාලනය කිරීමට අවශ්‍ය වනු ඇත. එබැවින් අහඹු අංකය ආරම්භ වන්නේ හා අවසන් වන්නේ කොතැනින්ද යන්න ඔබ විසින් නියම කළ යුතුය.

මෙම Next()ක්‍රමය මිනිත්තු සහ උපරිම යන පරාමිති දෙකක් පිළිගනී.

ඉතින් මගේ අහඹු අංකය 5 ත් 15 ත් අතර වීමට මට අවශ්‍ය නම්, මම කරන්නම්

int randomNumber = random.Next(5, 16)

මම භාවිතා කරන පන්තිය මෙයයි. වගේ වැඩ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);
    }
}

සෑම විටම නව අහඹු උත්පාදක යන්ත්රයක් භාවිතා කළ විට කුමක් සිදුවේද යන්න නිරූපණය කිරීමට මට අවශ්ය විය. ඔබට ක්‍රම දෙකක් හෝ පන්ති දෙකක් තිබේ යැයි සිතමු. බොළඳ ලෙස ඔබ ඒවා කේත කරන්නේ:

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

ඔබට වෙනස් හැඳුනුම්පත් දෙකක් ලැබෙනු ඇතැයි ඔබ සිතනවාද? NOPE

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

විසඳුම සෑම විටම තනි ස්ථිතික අහඹු උත්පාදක යන්ත්රයක් භාවිතා කිරීමයි. මෙවැනි:

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

ශක්තිමත් අහඹු බීජ සඳහා මම සෑම විටම භාවිතා කරන්නේ ක්‍රිප්ටෝ ආර්එන්ජී මිස වේලාව නොවේ.

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

අනාගත යොමු කිරීම සඳහා සටහනක් ලෙස.

ඔබ .NET Core භාවිතා කරන්නේ නම්, අහඹු සිදුවීම් කිහිපයක් පෙර මෙන් භයානක නොවේ. මෙම ප්‍රශ්නය 2010 සිට බව මම දනිමි, නමුත් මෙම ප්‍රශ්නය පැරණි නමුත් යම් ආකර්ෂණයක් ඇති හෙයින්, වෙනස ලේඛනගත කිරීම හොඳ දෙයක් යැයි මම සිතමි.

ටික කලකට පෙර මා ඇසූ මෙම ප්‍රශ්නයට ඔබ යොමු විය හැකිය:

මයික්‍රොසොෆ්ට් සසම්භාවී පෙරනිමි බීජ වෙනස් කළාද?

මූලික වශයෙන්, ඔවුන් පෙරනිමි බීජය සිට වෙනස් කර Environment.TickCountඇත Guid.NewGuid().GetHashCode(), එබැවින් ඔබ අහඹු සිදුවීම් 2 ක් නිර්මාණය කරන්නේ නම් එය එකම සංඛ්‍යා පෙන්වන්නේ නැත.

ගොනුව .NET Framework / .NET Core (2.0.0+) ට වඩා වෙනස් බව ඔබට දැක ගත හැකිය: https://github.com/dotnet/coreclr/pull/2192/commits/9f6a0b675e5ac0065a268554de49162c539ff66d

එය RNGCryptoServiceProvider තරම් ආරක්ෂිත නොවේ, නමුත් අවම වශයෙන් එය ඔබට අමුතු ප්‍රති .ල ලබා නොදේ.

නිර්ණායක ක්‍රියාවලියක් හරහා පරිගණකයක් විසින් ගණනය කරන ලද සංඛ්‍යා, අර්ථ දැක්වීම අනුව අහඹු විය නොහැක.

ඔබට අව්‍යාජ අහඹු සංඛ්‍යාවක් අවශ්‍ය නම්, අහඹු බව පැමිණෙන්නේ වායුගෝලීය ශබ්දය හෝ විකිරණශීලී ක්ෂය වීමෙනි.

ඔබට උදාහරණයක් ලෙස RANDOM.ORG උත්සාහ කළ හැකිය (එය කාර්ය සාධනය අඩු කරයි)

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

දෙවන වරහන් තුළ ඔබට අවශ්‍ය ඕනෑම අගයක් යොදන්න, කේතය ජනනය කිරීම සඳහා මුක්කු සහ ද්විත්ව පටිත්ත ලිවීමෙන් ඔබ නමක් සකසා ඇති බවට වග බලා ගන්න

මිනිත්තුවක් සහ උපරිමයක් අතර අහඹු සංඛ්‍යා උත්පාදනය කිරීමට ඔබට CSRNG අවශ්‍ය නම්, මෙය ඔබ සඳහා ය. එය Randomආරක්ෂිත අහඹු බීජ සමඟ පන්ති ආරම්භ කරනු ඇත .

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

කණගාටුයි, OP ට ඇත්ත වශයෙන්ම අහඹු intඅගයක් අවශ්‍ය වේ , නමුත් සරල අරමුණක් සඳහා ඔබට අහඹු BigIntegerඅගයක් අවශ්‍ය නම් දැනුම බෙදා ගැනීම සඳහා පහත ප්‍රකාශය භාවිතා කළ හැකිය:

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

පහත පරිදි ඔබට ඒකාකාරව බෙදා හරින අහඹු සංඛ්‍යා උත්පාදක යන්ත්‍රයක් අවශ්‍ය යැයි මම සිතමි. C # සහ C ++ ඇතුළුව බොහෝ ක්‍රමලේඛන භාෂාවල අහඹු අංකය ඒවා භාවිතා කිරීමට පෙර නිසි ලෙස මාරු නොකෙරේ. මෙයින් අදහස් කරන්නේ ඔබට එකම සංඛ්‍යාවක් නැවත නැවතත් ලැබෙනු ඇති බවයි, එය සැබවින්ම අහඹු නොවේ. එකම සංඛ්‍යාවක් නැවත නැවතත් ඇද ගැනීම වළක්වා ගැනීමට ඔබට බීජයක් අවශ්‍ය වේ. සාමාන්‍යයෙන්, මෙම කාර්යය සඳහා වේලාවට කිනිතුල්ලන් හරි ය. ඔබ සෑම විටම එකම බීජ භාවිතා කරන්නේ නම් ඔබට එකම අංකය නැවත නැවතත් ලැබෙන බව මතක තබා ගන්න. එබැවින් සෑම විටම විවිධ බීජ භාවිතා කිරීමට උත්සාහ කරන්න. බීජ සඳහා කාලය හොඳ ප්‍රභවයකි.

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

ඔබ සාමාන්‍ය බෙදා හැරීම සඳහා අහඹු සංඛ්‍යා උත්පාදක යන්ත්‍රයක් සොයන්නේ නම්, ඔබට බොක්ස්-මුලර් පරිවර්තනයක් භාවිතා කළ හැකිය. සසම්භාවී ගවුසියානු විචල්‍ය ප්‍රශ්නයේ යොයෝයොසෙෆ් විසින් පිළිතුර පරීක්ෂා කරන්න. ඔබට පූර්ණ සංඛ්‍යාවක් අවශ්‍ය බැවින්, අවසානයේ දී පූර්ණ සංඛ්‍යාවට ද්විත්ව අගයක් දැමිය යුතුය.

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)

සසම්භාවී ගවුසියානු විචල්‍යයන්

පහසුම ක්‍රමය බොහෝ විට Random.range(1, 3)මෙය 1 සහ 2 අතර සංඛ්‍යාවක් ජනනය කරනු ඇත.

අහඹු බීජ අගය සමඟ ඔබට පහත උත්සාහ කළ හැකිය:

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

string randomDigits = rnd.Next();

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

භාවිතා නොකරන්නේ ඇයි int randomNumber = Random.Range(start_range, end_range)?

සසම්භාවී එක් අවස්ථාවක් නැවත නැවත භාවිතා කරන්න

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

අහඹු ලෙස මෙතරම් ගැටලු ඇතිවීමට හේතුව සහ ඒවාට පිළියම් යෙදිය යුතු ආකාරය මෙම ලිපියෙන් විමසා බලයි. http://csharpindepth.com/Articles/Chapter12/Random.aspx

අහඹු සංඛ්‍යා නිර්මාණය කිරීමට මෙම සරල පියවර උත්සාහ කරන්න:

ශ්‍රිතය සාදන්න:

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

ඔබට අහඹු සංඛ්‍යා භාවිතා කිරීමට අවශ්‍ය ස්ථානයක ඉහත ශ්‍රිතය භාවිතා කරන්න. ඔබට එය පෙළ කොටුවක භාවිතා කිරීමට අවශ්‍ය යැයි සිතමු.

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

0 මිනිත්තු වන අතර 999 උපරිම වේ. ඔබට අවශ්‍ය ඕනෑම දෙයකට අගයන් වෙනස් කළ හැකිය.

විවිධ අරමුණු සඳහා උපකාර වන අහඹු සංඛ්‍යා ජනනය කරන ක්‍රම මට සෑම විටම තිබේ. මෙය ඔබටත් උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි:

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

පේළිගත කිරීම සඳහා ඉක්මන් සහ පහසු, බෙලෝ කේතය භාවිතා කරන්න:

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

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