[Zdroj] .NET/C# nový typ záznamu funkcí

Typ záznamu v C# je nová funkce zavedená v nejnovější verzi. Lze jej použít v mnoha situacích, včetně, ale nejen, následujících oblastí:

Neměnný datový objekt: Typ záznamu je neměnný, což znamená, že jakmile je vytvořen, nelze jeho hodnotu vlastnosti měnit. To je činí ideálními pro reprezentaci neměnných datových struktur, jako jsou přenosové objekty (DTO) nebo konfigurační nastavení.
Objekty hodnot: Typ záznamu lze použít k reprezentaci hodnotových objektů, jejichž rovnost je určena na základě hodnoty atributů místo referenční ekvivalence. To je činí ideálními pro porovnávání a ukládání hodnotových objektů, jako jsou datové rozsahy, souřadnicové body a další.
Pattern Matching: Typ záznamu lze použít společně s pattern matching, což je pohodlnější při práci s komplexními datovými strukturami. Můžete použít pattern matching k ověření a extrakci atributů objektu záznamu, abyste mohli provést příslušnou akci.
Immutable Collections: Typ záznamu lze použít s neměnnými typy kolekcí, jako jsou ImmutableList, ImmutableDictionary atd., k vytvoření objektů neměnných kolekcí. To zajišťuje, že obsah kolekce není upravován, čímž se zvyšuje spolehlivost a bezpečnost kódu.
To jsou jen některé z případů použití tohoto typu záznamu a můžete se rozhodnout, zda ho použijete podle svých konkrétních potřeb a struktury kódu.

pomocí System;
pomocí System.Collections.Generic;
pomocí System.Diagnostics;
pomocí System.Reflection;
pomocí System.Runtime.CompilerServices;
pomocí System.Security;
pomocí System.Security.Permissions;
pomocí System.Text;
pomocí Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembler: Runtime Comcombibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue | DebuggableAttribute.DebuggingModes.DisableOptimizations)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[modul: UnverifiableCode]
[modul: System.Runtime.CompilerServices.RefSafetyRules(11)]

[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
Informace o veřejné třídě : Srovnatelné<PersonInfo>
{
    [KompilátorGenerováno]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    soukromý čtecí řetězec <FirstName>k__BackingField;

    [KompilátorGenerováno]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    soukromý čtecí řetězec <LastName>k__BackingField;

    [KompilátorGenerováno]
    chráněný virtuální Typ EqualityContract
    {
        [KompilátorGenerováno]
        dostat
        {
            return typeof(PersonInfo);
        }
    }

    veřejný řetězec FirstName
    {
        [KompilátorGenerováno]
        dostat
        {
            návrat <FirstName>k__BackingField;
        }
        [KompilátorGenerováno]
        Init
        {
            <FirstName>k__BackingField = hodnota;
        }
    }

    veřejný řetězec Příjmení
    {
        [KompilátorGenerováno]
        dostat
        {
            vrátit <LastName>k__BackingField;
        }
        [KompilátorGenerováno]
        Init
        {
            <LastName>k__BackingField = hodnota;
        }
    }

    public PersonInfo(řetězec Jméno, řetězec Příjmení)
    {
        <FirstName>k__BackingField = Křestní jméno;
        <LastName>k__BackingField = Příjmení;
        základna.. ctor();
    }

    [KompilátorGenerováno]
    public overwrite string ToString()
    {
        StringBuilder stringBuilder = nový StringBuilder();
        stringBuilder.Append("PersonInfo");
        stringBuilder.Append(" { ");
        if (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(' ');
        }
        stringBuilder.Append('}');
        return stringBuilder.ToString();
    }

    [KompilátorGenerováno]
    chráněný virtuální bool PrintMembers (StringBuilder builder)
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        budovatel. Přidání("FirstName = ");
        budovatel. Připojit((objekt)Jméno);
        budovatel. Přidat(", příjmeníPříjmení = ");
        budovatel. Připojit((objekt)Příjmení);
        return true;
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [KompilátorGenerováno]
    veřejný statický bool operátor !=(PersonInfo vlevo, PersonInfo vpravo)
    {
        vrátit! (levá == pravá);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [KompilátorGenerováno]
    veřejný statický bool operátor ==(PersonInfo vlevo, PersonInfo vpravo)
    {
        return (objekt)left == right || ((objekt)left != null & left. Equals (vpravo);
    }

    [KompilátorGenerováno]
    public overfix int GetHashCode()
    {
        return (EqualityComparer<Type>. Default.GetHashCode(EqualityContract) * -1521134295 + EqualityComparer<string>. Default.GetHashCode(<FirstName>k__BackingField)) * -1521134295 + EqualityComparer<string>. Default.GetHashCode(<LastName>k__BackingField);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [KompilátorGenerováno]
    public override bool Equals (objektový obj)
    {
        return Equals(obj jako PersonInfo);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [KompilátorGenerováno]
    veřejný virtuální bool Equals (PersonInfo other)
    {
        return (objekt)toto == jiné || ((objekt)jiné != null && EqualityContract == jiné. EqualityContract & EqualityComparer<string>. Default.Equals(<FirstName>k__BackingField, jiné.<FirstName>k__BackingField) & EqualityComparer<string>. Default.Equals(<LastName>k__BackingField, jiné.<LastName>k__BackingField));
    }

    [KompilátorGenerováno]
    veřejný virtuální PersonInfo <Clone>$()
    {
        vrátit nový PersonInfo(this);
    }

    [KompilátorGenerováno]
    chráněný PersonInfo(původní PersonInfo)
    {
        <FirstName>k__BackingField = původní. <FirstName>k__BackingField;
        <LastName>k__BackingField = původní. <LastName>k__BackingField;
    }

    [KompilátorGenerováno]
    public void Deconstruct(out string FirstName, out string LastName)
    {
        Křestní jméno = toto. JménoJméno;
        Příjmení = toto. Příjmení;
    }
}

Jmenný prostor Microsoft.CodeAnalysis
{
    [KompilátorGenerováno]
    [Vloženo]
    interní uzavřená třída EmbeddedAttribute : Attribute
    {
    }
}

jmenný prostor System.Runtime.CompilerServices
{
    [KompilátorGenerováno]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
    interní zapečetěná třída NullableAttribute : Attribute
    {
        veřejný readonly bajt[] NullableFlags;

        public NullableAttribute(byte P_0)
        {
            bajt[] pole = nový bajt[1];
            array[0] = P_0;
            NullableFlags = pole;
        }

        public NullableAttribute(byte[] P_0)
        {
            NullableFlags = P_0;
        }
    }

    [KompilátorGenerováno]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
    interní zapečetěná třída NullableContextAttribute : Attribute
    {
        veřejný readonly bajt Flag;

        public NullableContextAttribute(byte P_0)
        {
            Vlajka = P_0;
        }
    }

    [KompilátorGenerováno]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
    interní zapečetěná třída RefSafetyRulesAttribute : Attribute
    {
        veřejně čtené pouze ve verzi;

        public RefSafetyRulesAttribute(int P_0)
        {
            Verze = P_0;
        }
    }
}

.NET/C# implementuje vlastní komparátor IEqualityComparer
https://www.itsvse.com/thread-10643-1-1.html