08. TANANYAG · C# ALAPOK
A Random osztály
ANIMÁCIÓ · NARRÁLT
Tanári bemutató: a program üres fájlból, sorról sorra épül fel, közben a tábla mutatja a memóriát, a kiértékelést és a konzolt. A futások valódi .NET-futtatásból származnak.
9,5 perc · 10 fejezet · hang és felirat · fejezetválasztó
Lejátszás
ANIMÁCIÓ · FELIRATOS
Rövid, hang nélküli összefoglaló a kód elemeiről, felirattal. Ismétléshez vagy a téma gyors felidézéséhez.
4,8 perc · felirat · saját lejátszósáv
Megnyitásnamespace _20250919_Random // A namespace (névtér) összefogja az ehhez a példához tartozó kódelemeket.
{ // Itt kezdődik a névtér kódblokkja.
internal class Program // A Program nevű osztály deklarációja.
{ // Itt kezdődik a Program osztály törzse.
static void Main(string[] args) // A Main a program belépési pontja.
{ // Itt kezdődik a Main metódus törzse.
Random random = new Random(); // Létrehozunk egy Random típusú objektumot. A new Random() példányosítja a Random osztályt, a létrejött objektumra a random változó hivatkozik.
double szam; // Létrehozunk egy double típusú változót, amelyben valós számokat fogunk tárolni.
for (int i = 0; i < 100; i++) // A ciklus 100 alkalommal fut le: i értéke 0-tól 99-ig változik.
{
// Az alábbi sorok különböző példák a Random osztály használatára.
// Egyszerre csak azt a sort érdemes bekapcsolni, amelyiket éppen ki szeretnénk próbálni.
//int egesz = random.Next(); // Nemnegatív int értéket ad vissza: 0 vagy annál nagyobb egész számot.
//int egesz = random.Next(10); // 0 és 10 közötti egész számot ad: 0 benne lehet, 10 már nem. Lehetséges értékek: 0..9.
//int egesz = random.Next(10, 20); // 10 és 20 közötti egész számot ad: 10 benne lehet, 20 már nem. Lehetséges értékek: 10..19.
szam = random.NextDouble(); // 0,0-nál nagyobb vagy egyenlő és 1,0-nál kisebb double értéket ad: 0.0 <= érték < 1.0.
Console.Write(szam + " "); // Kiírja az aktuálisan generált véletlen számot, majd egy szóközt.
}
Console.WriteLine(); // A 100 véletlen szám után új sort kezd.
Console.WriteLine($"A legnagyobb szám az int típusban: {int.MaxValue}"); // Kiírja az int típus által tárolható legnagyobb értéket.
Console.WriteLine($"A legkisebb szám az int típusban: {int.MinValue}"); // Kiírja az int típus által tárolható legkisebb értéket.
// Cél: 100 és 1000 közé eső valós szám előállítása két tizedesjegy pontossággal.
// Az alábbi három megoldás három különböző módszert mutat.
// Mivel ugyanabba a szam változóba írunk, a következő sor mindig felülírja az előző eredményét.
szam = Math.Round(random.Next(100, 1000) + random.NextDouble(), 2); // Egész rész: 100..999, ehhez 0 és 1 közötti törtrészt adunk, majd két tizedesjegyre kerekítünk.
szam = Math.Round(random.NextDouble() * 900 + 100, 2); // A [0,1) tartományt először 900 szélesre nyújtjuk, majd 100-zal eltoljuk: [100,1000), végül két tizedesjegyre kerekítünk.
szam = random.Next(10000, 100000) / 100.0; // 10000..99999 közötti egészből osztással két tizedesjegyes értéket készítünk: 100.00..999.99.
Console.WriteLine($"100 és 1000 közé eső valós szám 2 tizedes pontossággal: {szam}"); // Kiírja a legutolsó módszerrel előállított értéket.
} // Ez a záró kapcsos zárójel lezárja a Main metódust.
} // Ez a záró kapcsos zárójel lezárja a Program osztályt.
} // Ez az utolsó záró kapcsos zárójel lezárja a névteret.
/*
* A Random OSZTÁLY
* ----------------
*
* A C#/.NET Random osztálya pszeudovéletlen számok előállítására használható.
*
* A használatához először szükségünk van egy Random objektumra:
*
* Random random = new Random();
*
* A felépítése:
*
* Random random = new Random();
* ↓ ↓ ↓ ↓
* típus változó értékadó új Random
* neve operátor objektum
*
* A Random itt egy osztály.
* A new Random() létrehoz egy példányt ebből az osztályból.
* A random változó erre az objektumra hivatkozik.
*
* Ezután ezen az objektumon hívhatjuk meg például:
*
* random.Next()
* random.Next(10)
* random.Next(10, 20)
* random.NextDouble()
*/
/*
* PSZEUDOVÉLETLEN SZÁM
* -------------------
*
* A Random nem valódi fizikai véletlent állít elő.
*
* Egy algoritmus segítségével olyan számsorozatot generál,
* amely hétköznapi programozási feladatokhoz véletlenszerűnek tűnik.
*
* Ezt pszeudovéletlen számsorozatnak nevezzük.
*
* Tipikus felhasználás:
*
* játékok
* sorsolások gyakorlóprogramban
* tesztadatok
* véletlen feladatok
* szimulációk
*
* Fontos:
* biztonsági, jelszó- vagy titkosítási célra nem a Random osztályt
* kell használni, hanem kriptográfiai véletlenszám-generátort.
*/
/*
* random.Next()
* -------------
*
* A paraméter nélküli Next():
*
* random.Next()
*
* nemnegatív int értéket ad vissza.
*
* Vagyis:
*
* 0 vagy pozitív egész szám
*
* Például:
*
* int szám = random.Next();
*
* A visszatérési típus int.
*/
/*
* random.Next(maxValue)
* ---------------------
*
* Ha egy felső határt adunk meg:
*
* random.Next(10)
*
* akkor az eredmény:
*
* 0 <= érték < 10
*
* Lehetséges értékek:
*
* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
*
* A 0 benne van.
* A 10 nincs benne.
*
* Ezért mondjuk azt, hogy a felső határ kizárólagos
* vagy angolul exclusive upper bound.
*/
/*
* random.Next(minValue, maxValue)
* -------------------------------
*
* Két paraméterrel alsó és felső határt is megadhatunk:
*
* random.Next(10, 20)
*
* Az eredmény:
*
* 10 <= érték < 20
*
* Lehetséges értékek:
*
* 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
*
* A 10 benne van.
* A 20 nincs benne.
*
* Az alsó határ tehát inclusive, a felső pedig exclusive.
*
* Általánosan:
*
* random.Next(min, max)
*
* min <= eredmény < max
*/
/*
* random.NextDouble()
* -------------------
*
* A NextDouble() double típusú valós számot ad vissza:
*
* random.NextDouble()
*
* Tartománya:
*
* 0.0 <= érték < 1.0
*
* Vagyis a 0 lehetséges,
* az 1 viszont már nincs benne a tartományban.
*
* Például lehetséges eredmények:
*
* 0.153726...
* 0.847193...
* 0.004281...
*
* A metódus visszatérési típusa double.
*/
/*
* METÓDUSHÍVÁS A Random OBJEKTUMON
* --------------------------------
*
* Például:
*
* random.NextDouble()
*
* Felépítése:
*
* random . NextDouble ()
* ↓ ↓ ↓
* objektum metódus meghívás
*
* A pont (.) tagelérési operátor.
* Azt jelenti, hogy a random objektum valamely tagját használjuk.
*
* Ugyanez:
*
* random.Next(10, 20)
*
* Itt a 10 és a 20 a Next metódusnak átadott argumentumok.
*/
/*
* VISSZATÉRÉSI ÉRTÉK TÁROLÁSA
* ---------------------------
*
* A Random metódusai értéket adnak vissza.
*
* Például:
*
* double szam = random.NextDouble();
*
* A művelet sorrendje:
*
* 1. Meghívódik a random.NextDouble().
* 2. A metódus előállít egy double értéket.
* 3. A visszaadott érték bekerül a szam változóba.
*
* Ugyanez egész számmal:
*
* int szam = random.Next(1, 7);
*
* Ez például egy hagyományos hatoldalú dobókocka 1..6 közötti
* értékeinek modellezésére használható.
*/
/*
* TARTOMÁNY ÁTALAKÍTÁSA NextDouble() SEGÍTSÉGÉVEL
* ------------------------------------------------
*
* A NextDouble() alapból:
*
* [0, 1)
*
* tartományból ad számot.
*
* Ha 100 és 1000 közötti értéket szeretnénk:
*
* random.NextDouble() * 900 + 100
*
* Miért?
*
* 1. Kiindulás:
*
* [0, 1)
*
* 2. Szorozzuk 900-zal:
*
* [0, 900)
*
* 3. Hozzáadunk 100-at:
*
* [100, 1000)
*
* Általános képlet:
*
* random.NextDouble() * (max - min) + min
*
* ahol:
*
* min = alsó határ
* max = felső határ
*/
/*
* Math.Round()
* ------------
*
* A Math.Round() egy szám kerekítésére használható.
*
* Például:
*
* Math.Round(12.34567, 2)
*
* két tizedesjegyre kerekít.
*
* A második argumentum tehát azt adja meg,
* hány tizedesjegyre történjen a kerekítés.
*
* A programban:
*
* Math.Round(random.NextDouble() * 900 + 100, 2)
*
* először előállítjuk a véletlen számot,
* majd két tizedesjegyre kerekítjük.
*/
/*
* 100 ÉS 1000 KÖZÖTTI VALÓS SZÁM – 1. MÓDSZER
* -------------------------------------------
*
* random.Next(100, 1000) + random.NextDouble()
*
* Az első rész:
*
* random.Next(100, 1000)
*
* egy egész számot ad:
*
* 100 ... 999
*
* A második rész:
*
* random.NextDouble()
*
* ehhez hozzáad egy 0 és 1 közötti törtrészt.
*
* Például:
*
* 234 + 0.45127... = 234.45127...
*
* Ezután:
*
* Math.Round(..., 2)
*
* két tizedesjegyre kerekíti:
*
* 234.45
*/
/*
* 100 ÉS 1000 KÖZÖTTI VALÓS SZÁM – 2. MÓDSZER
* -------------------------------------------
*
* Math.Round(random.NextDouble() * 900 + 100, 2)
*
* Ez matematikailag közvetlenül alakítja át
* a [0,1) tartományt [100,1000) tartománnyá.
*
* A 900 azért szerepel benne, mert:
*
* 1000 - 100 = 900
*
* Általánosan:
*
* max - min
*
* adja meg a kívánt intervallum szélességét.
*/
/*
* 100 ÉS 1000 KÖZÖTTI VALÓS SZÁM – 3. MÓDSZER
* -------------------------------------------
*
* random.Next(10000, 100000) / 100.0
*
* Először egy egész szám készül:
*
* 10000 ... 99999
*
* Ezután 100.0-val osztjuk:
*
* 100.00 ... 999.99
*
* A 100.0 double típusú literál,
* ezért az osztás valós osztás lesz.
*
* Ha egész számokkal osztanánk:
*
* 12345 / 100
*
* akkor egész osztás történne, és a törtrész elveszne.
*
* Viszont:
*
* 12345 / 100.0
*
* eredménye:
*
* 123.45
*/
/*
* int.MaxValue ÉS int.MinValue
* ----------------------------
*
* A C# beépített numerikus típusai rendelkeznek olyan statikus tagokkal,
* amelyek megadják a tárolható szélső értékeket.
*
* int.MaxValue
*
* az int legnagyobb tárolható értéke.
*
* int.MinValue
*
* az int legkisebb tárolható értéke.
*
* Ezeket nem egy int változón keresztül érjük el,
* hanem közvetlenül a típus nevén keresztül:
*
* int.MaxValue
* int.MinValue
*/
/*
* FONTOS: EGY Random OBJEKTUMOT HASZNÁLUNK
* ----------------------------------------
*
* A program elején egyszer hozzuk létre:
*
* Random random = new Random();
*
* majd ezt használjuk újra minden véletlen számhoz:
*
* random.Next(...)
* random.NextDouble()
*
* Kezdő programokban ez egyszerű és jól követhető megoldás.
*
* Nem szükséges minden egyes szám előtt új Random objektumot létrehozni.
*/
/*
* Random ÉS for EGYÜTT
* --------------------
*
* A két témakör jól kombinálható.
*
* Például:
*
* for (int i = 0; i < 100; i++)
* {
* double szám = random.NextDouble();
* Console.WriteLine(szám);
* }
*
* A for ciklus határozza meg, hányszor ismételjük meg a műveletet,
* a Random pedig minden ismétlésnél előállít egy új pszeudovéletlen értéket.
*/
namespace _20250919_Random
{
internal class Program
{
static void Main(string[] args)
{
Random random = new Random();
double szam;
for (int i = 0; i < 100; i++)
{
szam = random.NextDouble();
Console.Write(szam + " ");
}
Console.WriteLine();
Console.WriteLine($"A legnagyobb szám az int típusban: {int.MaxValue}");
Console.WriteLine($"A legkisebb szám az int típusban: {int.MinValue}");
szam = Math.Round(random.Next(100, 1000) + random.NextDouble(), 2);
szam = Math.Round(random.NextDouble() * 900 + 100, 2);
szam = random.Next(10000, 100000) / 100.0;
Console.WriteLine($"100 és 1000 közé eső valós szám 2 tizedes pontossággal: {szam}");
}
}
}