[Sursă] .NET/C# noul tip de înregistrare de funcționalitate

Tipul de înregistrare în C# este o funcționalitate nouă introdusă în cea mai recentă versiune. Poate fi folosit în multe scenarii, inclusiv, dar fără a se limita la:

Obiect de date imuabil: Tipul de înregistrare este imuabil, ceea ce înseamnă că, odată creat, valoarea proprietății sale nu poate fi modificată. Acest lucru le face ideale pentru reprezentarea unor structuri de date imuabile, cum ar fi obiectele de transfer (DTO) sau setările de configurare.
Obiecte de valoare: Tipul de înregistrare poate fi folosit pentru a reprezenta obiecte de valoare a căror egalitate este determinată pe baza valorilor lor de atribute, nu de echivalența de referință. Acest lucru le face ideale pentru compararea și stocarea obiectelor de valoare precum intervale de date, puncte de coordonate și altele.
Potrivirea tiparului: Tipul de înregistrare poate fi folosit împreună cu potrivirea tiparelor, ceea ce îl face mai convenabil la lucrul cu structuri de date complexe. Poți folosi compararea tiparelor pentru a verifica și extrage valorile atributelor obiectului record, astfel încât să poți efectua acțiunea corespunzătoare.
Colecții Imutable: Tipul de înregistrare poate fi folosit împreună cu tipuri de colecții imutable precum ImmutableList, ImmutableDictionary etc., pentru a crea obiecte de colecție imuabile. Acest lucru asigură că conținutul colecției nu este modificat, îmbunătățind astfel fiabilitatea și securitatea codului.
Acestea sunt doar câteva dintre cazurile de utilizare ale tipului de înregistrare, iar tu poți decide dacă să folosești tipul de înregistrare în funcție de nevoile tale specifice și de structura codului.

folosind Sistem;
folosind System.Collections.Generic;
folosind System.Diagnostics;
folosind System.Reflection;
folosind System.Runtime.CompilerServices;
folosind System.Security;
folosind System.Security.Permissions;
folosind System.Text;
folosind Microsoft.CodeAnalysis;

[asamblare: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditandContinue | DebuggableAttribute.DebuggingModes.DisableOptimizations)]
[asamblare: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[asamblare: AssemblyVersion("0.0.0.0")]
[modul: Cod Neverificabil]
[modul: System.Runtime.CompilerServices.RefSafetyRules(11)]

[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
Clasa publică PersonInfo : IEquatable<PersonInfo>
{
    [CompilatorGenerat]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    șirul privat de citire <FirstName>k__BackingField;

    [CompilatorGenerat]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    șirul privat de citire <LastName>doar k__BackingField;

    [CompilatorGenerat]
    Contractul de Egalitate de Tip Virtual protejat
    {
        [CompilatorGenerat]
        obține
        {
            return typeof(PersonInfo);
        }
    }

    Șirul public Nume
    {
        [CompilatorGenerat]
        obține
        {
            <FirstName>întoarcerea k__BackingField;
        }
        [CompilatorGenerat]
        Init
        {
            <FirstName>k__BackingField = valoare;
        }
    }

    șirul public Nume de familie
    {
        [CompilatorGenerat]
        obține
        {
            <LastName>întoarcerea k__BackingField;
        }
        [CompilatorGenerat]
        Init
        {
            <LastName>k__BackingField = valoare;
        }
    }

    public PersonInfo(șir Nume, șir NumePrenume)
    {
        <FirstName>k__BackingField = Prenume;
        <LastName>k__BackingField = NumeDeFamilie;
        bază.. ctor();
    }

    [CompilatorGenerat]
    șirul de suprascriere publică ToString()
    {
        StringBuilder stringBuilder = noul StringBuilder();
        stringBuilder.Append("PersonInfo");
        stringBuilder.Append(" { ");
        dacă (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(' ');
        }
        stringBuilder.Append('}');
        return stringBuilder.ToString();
    }

    [CompilatorGenerat]
    PrintMembers virtuali protejați (StringBuilder builder)
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        constructor. Anexă("Prenume = ");
        constructor. Adaugă((obiect)Nume);
        constructor. Adaugă(", Nume de Familie = ");
        constructor. Adaugă((obiect)NumeNume);
        întoarcerea cu adevărat;
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [CompilatorGenerat]
    operator static public !=(PersonInfo stânga, PersoanaInfo dreapta)
    {
        restitui! (stânga == dreapta);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [CompilatorGenerat]
    operator bool static public ==(PersonInfo stânga, PersonaInfo dreapta)
    {
        return (obiect)left == dreapta || ((obiect)left != null && left. Egal (dreapta));
    }

    [CompilatorGenerat]
    public override int GetHashCode()
    {
        return (EqualityComparer<Type>. Implicit.GetHashCode(EqualityContract) * -1521134295 + <string>EqualityComparer. Default.GetHashCode(<FirstName>k__BackingField)) * -1521134295 + <string>EqualityComparer. Implicit.GetHashCode(<LastName>k__BackingField);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [CompilatorGenerat]
    public override bool Egal (obiect obj)
    {
        return Egal (obj ca PersonInfo);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [CompilatorGenerat]
    public virtual bool egal (PersonInfo altul)
    {
        return (obiect)this == altele || ((obiect)alt != nul && EqualityContract == altceva. EqualityContract & <string>EqualityComparer. Implicit. Egal cu <FirstName>(k__BackingField, alt.<FirstName>k__BackingField) & <string>EqualityComparer. Implicit. Egal <LastName>k__BackingField, alt.<LastName>k__BackingField));
    }

    [CompilatorGenerat]
    public, virtual, PersonInfo <Clone>$()
    {
        return new PersonInfo(this);
    }

    [CompilatorGenerat]
    PersonInfo protejat (PersonInfo original)
    {
        <FirstName>k__BackingField = original. <FirstName>k__BackingField;
        <LastName>k__BackingField = original. <LastName>k__BackingField;
    }

    [CompilatorGenerat]
    public void Deconstruct(string out FirstName, out string NumeFamilie)
    {
        Prenume = asta. Prenume;
        Nume de Familie = asta. NumeDe Familie;
    }
}

Spațiul de nume Microsoft.CodeAnalysis
{
    [CompilatorGenerat]
    [Încorporat]
    clasa sigilată internă EmbeddedAttribute : Attribute
    {
    }
}

Spațiul de nume System.Runtime.CompilerServices
{
    [CompilatorGenerat]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
    clasa sigilată internă NullableAttribute : Attribute
    {
        octet public doar pentru citire[] NullableFlags;

        public NullableAttribute(byte P_0)
        {
            octet[] tablă = octet nou[1];
            array[0] = P_0;
            NullableFlags = tablou;
        }

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

    [CompilatorGenerat]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
    clasa sigilată internă NullableContextAtribut : Atribut
    {
        Byte public doar pentru citire Flag;

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

    [CompilatorGenerat]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
    clasă sigilată internă RefSafetyRulesAtribut : Atribut
    {
        versiune publică readonly int;

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

.NET/C# implementează comparatorul personalizat IEqualityComparer
https://www.itsvse.com/thread-10643-1-1.html