Helló C#! Helló Világ! 2.1

  2. Home
  4. Docs
  6. Helló C#! Helló Világ! 2.1
  8. 13. Modern C# és .NET
  10. .NET 6 újdonságok

.NET 6 újdonságok

ArgumentNullException.ThrowIfNull

Az ArgumentNullException kivétel ThrowIfNull metódusa leegyszerűsíti az ArgumentNullException kivételek dobását:

void Method(string parameter)
{
    //.NET 6 előtt:
    if (parameter == null)
        throw new ArgumentNullException(nameof(parameter));

    //.NET 6 óta:
    ArgumentNullException.ThrowIfNull(parameter);
}

Kriptográfiailag biztos véletlenszám-generálás

A modern biztonságos titkosítások működéséhez elengedhetetlen egy kriptográfiailag biztonságos véletlenszám-generátor1. A .NET korábbi változataiban is megtalálható volt egy ilyen komponens, de ennek a használata picit körülményes volt. Ezt egyszerűsíti le a RandomNumberGenerator osztály GetBytes metódusa.

//16 byte véletlen adat
byte[] random = RandomNumberGenerator.GetBytes(16);

Task.WaitAsync

A WaitAsync metódust egy Task típusú objektumon tudjuk meghívni. Lényegében arra jó, hogy egy Task befejezésére várjunk aszinkron módon. Ha a paraméternek adott idő lejárt, akkor a Task-ot, amin meghívtuk, Completed állapotba billenti. Az időt egy TimeSpan példányban tudjuk megadni. Opcionálisan kiegészíthetjük egy CancellationToken példánnyal is.

Task dload = LongRunningDownload();
//Az eredeti task maximum 10 másodpercig futhat
await dload.WaitAsync(TimeSpan.FromSeconds(10));

Natív memória allokáció

Platform invoke esetén szükségünk lehet natív memória allokálására, hogy a natív hívásunk értéket tudjon visszaadni. Ennek a mikéntjét egyszerűsíti a NativeMemory osztály Alloc metódusa, ami lényegében a C# megfelelője a malloc c hívásnak. Nem meglepő módon a NativeMemory osztály metódusait unsafe kontextusban használhatjuk.

using System.Runtime.InteropServices;

unsafe
{
    //100 byte allokálása
    byte* buffer = (byte*)NativeMemory.Alloc(100);
    //natív memória felszabadítása
    NativeMemory.Free(buffer);
}

Parallel.ForEachAsync

Hasonló a Parallel.ForEach metódusához. Több Task párhuzamosítására jó egy olyan kollekció esetén, ami implementálja az IAsyncEnumerable 2 felületet:

List<int> numbers = new List<int>(100) { 1, 2, 3 };

//Mivel Task a visszatérése, await-el várakozhatunk rá
await Parallel.ForEachAsync(numbers,
                            async (item, cancellationToken) =>
{
    await Task.Delay(item);
});

A fenti példában a cancellationToken egy kötelező paramétere az aszinkron delegáltnak. Ezt használhatjuk arra, hogy kultúráltan megszakítsuk a párhuzamosan futtatott Task-ot.

  1. A kriptográfia számára megfelelÅ‘ véletlenszám generátorokat kriptográfiailag biztonságos pszeudó véletlenszám generátornak nevezzük (CSPRNG). Két feltételt kell teljesítenie egy ilyen algoritmusnak: át kell mennie a következÅ‘ bit teszten és ki kell állnia az állapot kompromittálódási tesztet. Egy bitsorozat átmegy a következÅ‘ bit teszten, ha a támadó a bitsorozat bármely i-edik bit elÅ‘tti sorozatot ismerve nem képes megmondani belátható idÅ‘n belül i+1 bit értékét matematikai számításokkal levezetve. Amennyiben a támadónak sikerült kitalálnia a véletlenszám-generátor jelenlegi állapotát, és ennek ismeretében sikerül kitalálnia a következÅ‘ állapotot, akkor az algoritmus megbukott az állapot kompromittálódási teszten.↩

  2. Lásd Aszinkron IEnumerable↩

Tags , ,