[Quelle] .NET/C# neuer Feature-Datensatz

Der Datensatztyp in C# ist eine neue Funktion, die in der neuesten Version eingeführt wurde. Sie kann in vielen Szenarien verwendet werden, darunter, aber nicht beschränkt auf die folgenden:

Unveränderliches Datenobjekt: Der Datensatztyp ist unveränderlich, das heißt, nach der Erstellung kann sein Eigenschaftswert nicht mehr geändert werden. Dies macht sie ideal zur Darstellung unveränderlicher Datenstrukturen wie Transferobjekte (DTOs) oder Konfigurationseinstellungen.
Wertobjekte: Der Datensatztyp kann verwendet werden, um Wertobjekte darzustellen, deren Gleichheit anhand ihrer Attributwerte und nicht durch Referenzäquivalenz bestimmt wird. Das macht sie ideal, um Wertobjekte wie Datumsbereiche, Koordinatenpunkte und mehr zu vergleichen und zu speichern.
Mustererkennung: Der Datensatztyp kann zusammen mit Mustererkennung verwendet werden, was es bei der Arbeit mit komplexen Datenstrukturen bequemer macht. Sie können Mustererkennung verwenden, um die Attributwerte des Datensatzobjekts zu überprüfen und zu extrahieren, damit Sie die entsprechende Aktion ausführen können.
Unveränderliche Sammlungen: Der Datensatztyp kann mit unveränderlichen Sammlungstypen wie ImmutableList, ImmutableDictionary usw. verwendet werden, um unveränderliche Sammlungsobjekte zu erstellen. Dies stellt sicher, dass der Inhalt der Sammlung nicht verändert wird, wodurch die Zuverlässigkeit und Sicherheit des Codes verbessert werden.
Dies sind nur einige der Anwendungsfälle für den Datensatztyp, und Sie können entscheiden, ob Sie den Datensatztyp basierend auf Ihren spezifischen Anforderungen und Ihrer Codestruktur verwenden.

mit System;
mit System.Collections.Generic;
mit System.Diagnostics;
mit System.Reflection;
unter Verwendung von System.Runtime.CompilerServices;
mit System.Security;
Verwendung von System.Security.Permissions;
mit System.Text;
mit Microsoft.CodeAnalysis;

[Zusammenstellung: CompilationRelaxations(8)]
[Assembly: RuntimeCompatibility(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: Unverifizierbarer Code]
[Modul: System.Runtime.CompilerServices.RefSafetyRules(11)]

[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
öffentliche Klasse PersonInfo : IEquatable<PersonInfo>
{
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private <FirstName>Readonly-Zeichenkette k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private Readonly-String <LastName>k__BackingField;

    [CompilerGenerated]
    geschützter virtueller Typ-Gleichheitsvertrag
    {
        [CompilerGenerated]
        Erhalten
        {
            return typeof(PersonInfo);
        }
    }

    öffentliche Zeichenkette FirstName
    {
        [CompilerGenerated]
        Erhalten
        {
            <FirstName>k__BackingField zurückkehren;
        }
        [CompilerGenerated]
        Anfang
        {
            <FirstName>k__BackingField = Wert;
        }
    }

    öffentlicher String LastName
    {
        [CompilerGenerated]
        Erhalten
        {
            <LastName>kehren Sie k__BackingField zurück;
        }
        [CompilerGenerated]
        Anfang
        {
            <LastName>k__BackingField = Wert;
        }
    }

    öffentliche PersonInfo(Zeichenkette Vorname, Zeichenkette Nachname)
    {
        <FirstName>k__BackingField = Vorname;
        <LastName>k__BackingField = Nachname;
        Basis.. ctor();
    }

    [CompilerGenerated]
    öffentliche Übersteuerungs-String ToString()
    {
        StringBuilder stringBuilder = neuer StringBuilder();
        stringBuilder.Append("PersonInfo");
        stringBuilder.Append(" { ");
        wenn (PrintMembers(stringBuilder))
        {
            stringBuilder.Append(' ');
        }
        stringBuilder.Append('}');
        return stringBuilder.ToString();
    }

    [CompilerGenerated]
    geschützte virtuelle bool PrintMitglieder (StringBuilder-Builder)
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        Bauherr. Anhang ("VorName = ");
        Bauherr. Anhang((Objekt)Vorname);
        Bauherr. Anhang (", Nachname = ");
        Bauherr. Anhang((Objekt)Nachname);
        Return true;
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [CompilerGenerated]
    öffentlicher statischer Bool-Operator!=(PersonInfo links, PersonInfo rechts)
    {
        Rückgabe! (links == rechts);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [CompilerGenerated]
    öffentlicher statischer Bool-Operator ==(PersonInfo links, PersonInfo rechts)
    {
        Zurück (Objekt)links == rechts || ((Objekt)left != null && left. Gleich (rechts));
    }

    [CompilerGenerated]
    öffentliche Überschreibung int GetHashCode()
    {
        Rückkehr (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)]
    [CompilerGenerated]
    öffentliche Übersteuerung bool Gleich (Objekt obj)
    {
        returnieren Equals (obj als PersonInfo);
    }

    [System.Runtime.CompilerServices.NullableContext(2)]
    [CompilerGenerated]
    öffentliche virtuelle Bool Equals (PersonInfo andere)
    {
        Return (Objekt)dies == Sonstiges || ((Objekt)anderes != null && Gleichheitsvertrag == andere. EqualityContract & EqualityComparer<string>. Default.Gleich(<FirstName>k__BackingField, andere.<FirstName>k__BackingField) & EqualityComparer<string>. Default.Gleich(<LastName>k__BackingField, andere.<LastName>k__BackingField));
    }

    [CompilerGenerated]
    öffentliche virtuelle PersonInfo <Clone>$()
    {
        neue PersonInfo(this) zurückgeben;
    }

    [CompilerGenerated]
    geschützte PersonInfo (PersonInfo original)
    {
        <FirstName>k__BackingField = original. <FirstName>k__BackingField;
        <LastName>k__BackingField = original. <LastName>k__BackingField;
    }

    [CompilerGenerated]
    public void Deconstruct (rausgehende Zeichenfolge Vorname, aussteigende Zeichenkette Nachnamen)
    {
        FirstName = das. Vorname;
        Nachname = das. Nachname;
    }
}

Namespace Microsoft.CodeAnalysis
{
    [CompilerGenerated]
    [Eingebettet]
    interne versiegelte Klasse EmbeddedAttribute : Attribute
    {
    }
}

Namespace System.Runtime.CompilerServices
{
    [CompilerGenerated]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeZiele.Feld | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
    interne versiegelte Klasse NullableAttribute : Attribut
    {
        öffentliches Readonly-Byte[] NullableFlags;

        public NullableAttribute(byte P_0)
        {
            byte[] Array = neues Byte[1];
            Array[0] = P_0;
            NullableFlags = Array;
        }

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

    [CompilerGenerated]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = falsch, Inherited = false)]
    interne versiegelte Klasse NullableContextAttribute : Attribute
    {
        öffentliches Readnur-Byte-Flag;

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

    [CompilerGenerated]
    [Microsoft.CodeAnalysis.Embedded]
    [AttributeUsage(AttributeTargets.Module, AllowMultiple = falsch, Inherited = false)]
    interne versiegelte Klasse RefSafetyRulesAttribute : Attribut
    {
        öffentlich lesbar-nur-int Version;

        öffentliches RefSafetyRulesAttribute(int P_0)
        {
            Version = P_0;
        }
    }
}

.NET/C# implementiert den benutzerdefinierten IEqualityComparator
https://www.itsvse.com/thread-10643-1-1.html