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 9 újdonságok

.NET 9 újdonságok

OrderedDictionary

Az OrderedDictionary<TKey, TValue> egy olyan Dictionary kollekció, amely a kulcs típuson kívül index alapon is elérhető. Lényegében olyan, mintha kulcs-érték párokat tárolnánk egy listában úgy, hogy közben a kulcs alapján is tudunk gyorsan keresni, mint egy Dictionary típusban. Ez a kollekció egyszerre implementálja az IDictionary<TKey,TValue> és a IList<System.Collections.Generic.KeyValuePair<TKey,TValue>> interfészeket.

OrderedDictionary<string, int> d = new()
{
    ["a"] = 1,
    ["b"] = 2,
    ["c"] = 3,
};

d.Add("d", 4);
d.RemoveAt(0);
d.RemoveAt(2);
d.Insert(0, "e", 5);

foreach (KeyValuePair<string, int> entry in d)
{
    Console.WriteLine(entry);
}

A program kimenete:

$
[e, 5]
[b, 2]
[c, 3]

UUID v7

A Guid típus .NET 1.0 óta rendelkezésre áll. Ez egy 128 bites, garantáltan egyedi azonosító, ami a UUID specifikáció 4.0-ás változatát implementálja. Ez azt jelenti, hogy mind a 128 bit véletlenszerűen generált. Azonban ennek a generálási sémának vannak hátulütői, például, ha GUID típust akarunk elsődleges kulcsnak használni egy adatbázisban. Ebben az esetben a véletlenszerűség miatt a beszúrás sebessége nagyobb tábláknál le tud lassulni, mivel a legtöbb adatbázis-kezelő rendszer igyekszik elsődleges kulcs alapján rendezetten tárolni az adatokat a gyors keresés miatt. Ha véletlenszerűen generáljuk a kulcsokat, akkor minden egyes beszúrás extra rendezést von magával.

Ezt a hátrányt orvosolja az UUID specifikáció 7-es verziója, amiben a legnagyobb helyi értéken lévő 48 bit a generálás dátumát és idejét reprezentálják 100ms felbontásban. Ebből adódóan a 7-es verziójú UUID azonosítók rendezettek és nyugodtan használhatóak adatbázis-kezelő rendszerekben is.

V7-es UUID generáláshoz a Guid.CreateVersion7() vagy Guid. CreateVersion7(DateTimeOffset timestamp) metódusait használhatjuk .NET 9-től kezdve.

JsonSchemaExporter és JsonStringEnumMemberName

A .NET 9-es JsonSerializer egyik újdonsága, hogy az enum típusaink szöveges szerializációjakor lehetőségünk van a szerializált értékek nevének egyedi meghatározására a JsonStringEnumMemberName attribútummal, amit a szerializált enum értékeinél alkalmazhatunk.

enum MyEnum
{
    Value1 = 1,
    [JsonStringEnumMemberName("Custom enum value")]
    Value2 = 2,
}

A JSON schema egy JSON alapú leírónyelv, ami JSON dokumentumok szerkezetét és érvényességi szabályait hivatott leírni. A céljai hasonlóak, mint az XSD-nek XML-ek esetén. Azonban ellentétben az XSD-vel, a JSON Schema jelenleg is csak „vázlat” stádiumban érhető el, vagyis a specifikációja nem véglegesített még. A .NET 9 bevezet egy Schema Exportert, ami egy alap sémát tud generálni. Ezt mi magunk személyre tudjuk szabni úgy, hogy a JsonSchemaExporterOptions típusban kapunk egy TransformSchemaNode tulajdonságot, aminek átadhatunk egy saját metódust és beleszólhatunk a JSON generálásba.

Ennek segítségével a specifikációból (https://json-schema.org/specification ) azt implementálhatjuk, ami nekünk kell. Az alábbi példa a Description attribútum alapján leírást generál a séma dokumentumunkba:

JsonSchemaExporterOptions exporterOptions = new()
{
    TransformSchemaNode = (context, schema) =>
    {
        // Determine if a type or property and extract the relevant attribute provider
        ICustomAttributeProvider? attributeProvider = context.PropertyInfo is not null
            ? context.PropertyInfo.AttributeProvider
            : context.TypeInfo.Type;

        // Look up any description attributes
        DescriptionAttribute? descriptionAttr = attributeProvider?
            .GetCustomAttributes(inherit: true)
            .Select(attr => attr as DescriptionAttribute)
            .FirstOrDefault(attr => attr is not null);

        // Apply description attribute to the generated schema
        if (descriptionAttr != null)
        {
            if (schema is not JsonObject jObj)
            {
                // Handle the case where the schema is a boolean
                JsonValueKind valueKind = schema.GetValueKind();
                Debug.Assert(valueKind is JsonValueKind.True or JsonValueKind.False);
                schema = jObj = new JsonObject();
                if (valueKind is JsonValueKind.False)
                {
                    jObj.Add("not", true);
                }
            }

            jObj.Insert(0, "description", descriptionAttr.Description);
        }

        return schema;
    }
};

JsonNode schema = options.GetJsonSchemaAsNode(typeof(Person), exporterOptions);

Console.WriteLine(schema.ToString());

[Description("A person")]
public record class Person
{
    [Description("The name of the person")]
    public required string Name { get; init; }
}

A program kimenete:

$
{
  "description": "A person",
  "type": ["object", "null"],
  "properties": {
    "Name": { "description": "The name of the person", "type": "string" }
  },
  "required": ["Name"]
}

Lock osztály

A zárolásra a lock blokk a C# legeslegelső verziója óta létezik és a szálkezelésnél tárgyalt módon bármilyen objektum típust használhatunk zárolásra. A .NET 9 azonban bevezeti a Lock típust, ami egy optimalizált zárolást valósít meg és szituációtól függően 3-10%-kal gyorsabb működést eredményez. Ez nem tűnik így elsőre soknak, de egy amúgy is költséges művelet esetén ez igencsak nagy előny tud lenni, főleg, hogy csak a típust kell kicserélnünk.

var lockObject = new Lock(); // a régi new object() helyett

lock (lockObject) 
{
    // zárolást igénylő kódrészlet
}
Tags , ,