[Źródło] .NET/C# nowy typ rekordu funkcji

Typ rekordu w C# to nowa funkcja wprowadzona w najnowszej wersji. Może być używany w wielu sytuacjach, w tym między innymi w następujących sytuacjach:

Niezmienny obiekt danych: Typ rekordu jest niezmienny, co oznacza, że po utworzeniu jego wartość właściwości nie może być zmieniona. Czyni je to idealnymi do reprezentowania niezmiennych struktur danych, takich jak obiekty transferowe (DTO) czy ustawienia konfiguracyjne.
Obiekty wartości: Typ rekordu może być używany do reprezentowania obiektów wartości, których równość jest określana na podstawie wartości atrybutów, a nie równoważności referencyjnej. Dzięki temu są idealne do porównywania i przechowywania obiektów wartościowych, takich jak zakresy dat, punkty współrzędnych i inne.
Dopasowanie wzorców: Typ rekordu może być używany razem z dopasowywaniem wzorców, co czyni go wygodniejszym przy pracy ze złożonymi strukturami danych. Możesz użyć wzorcowego dopasowania, aby sprawdzić i wyodrębnić wartości atrybutów obiektu rekordu, aby wykonać odpowiednią akcję.
Kolekcje niezmienne: Typ rekordu może być używany z niezmiennymi typami kolekcji, takimi jak ImmutableList, ImmutableDictionary itp., do tworzenia obiektów kolekcji niezmiennych. Zapewnia to, że treść kolekcji nie jest modyfikowana, co poprawia niezawodność i bezpieczeństwo kodu.
To tylko kilka przypadków użycia tego typu rekordu, a Ty możesz zdecydować, czy go użyć, w zależności od swoich potrzeb i struktury kodu.

z wykorzystaniem System;
używając System.Collections.Generic;
za pomocą System.Diagnostics;
używając System.Reflection;
używając System.Runtime.CompilerServices;
używając System.Security;
używając System.Security.Permissions;
używając System.Text;
używając Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: Runtime Compatibility(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")]
[moduł: UnverifiableCode]
[moduł: System.Runtime.CompilerServices.RefSafetyRules(11)]

[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
Osoba w klasie publicznej: IEw.<PersonInfo>
{
    [KompilatorGenerowany]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    prywatny ciąg tekstu tylko do odczytu <FirstName>k__BackingField;

    [KompilatorGenerowany]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    prywatny k__BackingField tekstu tylko do odczytu<LastName>;

    [KompilatorGenerowany]
    chroniony wirtualny Typ EqualityContract
    {
        [KompilatorGenerowany]
        Pobierz
        {
            return typeof(PersonInfo);
        }
    }

    publiczny string FirstName
    {
        [KompilatorGenerowany]
        Pobierz
        {
            powrót <FirstName>k__BackingField;
        }
        [KompilatorGenerowany]
        Init
        {
            <FirstName>k__BackingField = wartość;
        }
    }

    publiczny string Nazwisko
    {
        [KompilatorGenerowany]
        Pobierz
        {
            powrót <LastName>k__BackingField;
        }
        [KompilatorGenerowany]
        Init
        {
            <LastName>k__BackingField = wartość;
        }
    }

    public PersonInfo(ciąg Imię, ciąg Nazwisko)
    {
        <FirstName>k__BackingField = Imię;
        <LastName>k__BackingField = Nazwisko;
        baza.. ctor();
    }

    [KompilatorGenerowany]
    public override string ToString()
    {
        StringBuilder stringBuilder = nowy StringBuilder();
        stringBuilder.Append("PersonInfo");
        stringBuilder.Append(" { ");
        if (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(' ');
        }
        stringBuilder.Append('}');
        return stringBuilder.ToString();
    }

    [KompilatorGenerowany]
    chroniony wirtualny bool PrintMembers (StringBuilder builder)
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        budowniczy. Dodaj("FirstName = ");
        budowniczy. Dodaj((object)FirstName);
        budowniczy. Dołączymy(", NazwiskoNazwiska = ");
        budowniczy. Dodaj (obiekt)Nazwisko);
        return true;
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [KompilatorGenerowany]
    publiczny statyczny operator boolu !=(PersonInfo po lewej, PersonInfo po prawej)
    {
        wrócić! (lewa == prawa);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [KompilatorGenerowany]
    publiczny statyczny bool operator ==(PersonInfo po lewej, PersonInfo po prawej)
    {
        return (object)left == right || ((obiekt)left != null & left. Równy (po prawej);
    }

    [KompilatorGenerowany]
    public overpass 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)]
    [KompilatorGenerowany]
    public override bool Equals (object obj)
    {
        return Equals(obj jako PersonInfo);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [KompilatorGenerowany]
    publiczny wirtualny bool Equals (PersonInfo inne)
    {
        return (obiekt)to == inne || ((obiekt)inne != null && EqualityContract == inne. EqualityContract & EqualityComparer<string>. Default.Equals(<FirstName>k__BackingField, inne.<FirstName>k__BackingField) & EqualityComparer<string>. Default.Equal(<LastName>k__BackingField, inne.<LastName>k__BackingField));
    }

    [KompilatorGenerowany]
    publicznie wirtualne PersonInfo <Clone>$()
    {
        zwróć nową PersonInfo(to);
    }

    [KompilatorGenerowany]
    chroniona PersonInfo (oryginalna PersonInfo)
    {
        <FirstName>k__BackingField = oryginalny. <FirstName>k__BackingField;
        <LastName>k__BackingField = oryginalny. <LastName>k__BackingField;
    }

    [KompilatorGenerowany]
    public void Deconstruct(out string FirstName, out string LastName)
    {
        ImięImię = to. Imię;
        Nazwisko = to. Nazwisko;
    }
}

przestrzeń nazw Microsoft.CodeAnalysis
{
    [KompilatorGenerowany]
    [Wbudowane]
    wewnętrzna zamknięta klasa EmbeddedAttribute : Attribute
    {
    }
}

przestrzeń nazw System.Runtime.CompilerServices
{
    [KompilatorGenerowany]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
    wewnętrzna zamknięta klasa NullableAttribute : Attribute
    {
        public readonly byte[] NullableFlags;

        public NullableAttribute(byte P_0)
        {
            bajt[] array = nowy bajt[1];
            array[0] = P_0;
            NullableFlags = tablica;
        }

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

    [KompilatorGenerowany]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
    wewnętrzna zamknięta klasa NullableContextAttribute : Attribute
    {
        publiczny bajt tylko do odczytu Flag;

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

    [KompilatorGenerowany]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
    wewnętrzna zamknięta klasa RefSafetyRulesAttribute : Attribute
    {
        publiczna wersja tylko do odczytu int;

        publiczna RefSafetyRulesAttribute(int P_0)
        {
            Wersja = P_0;
        }
    }
}

.NET/C# implementuje niestandardowy komparator IEqualityComparer
https://www.itsvse.com/thread-10643-1-1.html