Sdílet prostřednictvím

Záznamy (referenční dokumentace jazyka C#)

  • Článek

Modifikátor slouží record k definování typu odkazu , který poskytuje předdefinované funkce pro zapouzdření dat. Syntaxe record class jako synonymum pro objasnění typu odkazu a record struct pro definici typu hodnoty s podobnou funkčností.

Když deklarujete primární konstruktor v záznamu, kompilátor generuje veřejné vlastnosti pro parametry primárního konstruktoru. Parametry primárního konstruktoru záznamu se označují jako poziční parametry. Kompilátor vytvoří poziční vlastnosti , které zrcadlí primární konstruktor nebo poziční parametry. Kompilátor syntetizuje vlastnosti pro primární parametry konstruktoru record u typů, které nemají modifikátor.

Následující dva příklady ukazují record (nebo record class) odkazové typy:

public record Person(string FirstName, string LastName);

public record Person
{
    public required string FirstName { get; init; }
    public required string LastName { get; init; }
};

Následující dva příklady ukazují record struct typy hodnot:

public readonly record struct Point(double X, double Y, double Z);

public record struct Point
{
    public double X { get; init; }
    public double Y { get; init; }
    public double Z { get; init; }
}

Můžete také vytvořit záznamy s proměnlivými vlastnostmi a poli:

public record Person
{
    public required string FirstName { get; set; }
    public required string LastName { get; set; }
};

Struktury záznamů můžou být také proměnlivé, a to jak struktury pozičních záznamů, tak struktury záznamů bez pozičních parametrů:

public record struct DataMeasurement(DateTime TakenAt, double Measurement);

public record struct Point
{
    public double X { get; set; }
    public double Y { get; set; }
    public double Z { get; set; }
}

Záznamy sice můžou být proměnlivé, ale primárně slouží k podpoře neměnných datových modelů. Typ záznamu nabízí následující funkce:

Předchozí příklady ukazují několik rozdílů mezi záznamy, které jsou odkazovými typy a záznamy, které jsou typy hodnot:

  • A record nebo deklaruje record class typ odkazu. Klíčové class slovo je volitelné, ale může pro čtenáře přidat přehlednost. A record struct deklaruje typ hodnoty.
  • Poziční vlastnosti jsou neměnné v objektu a .record classreadonly record struct Jsou proměnlivé v objektu record struct.

Zbývající část tohoto článku popisuje oba record class typy i record struct typy. Rozdíly jsou podrobně popsané v jednotlivých částech. Měli byste se rozhodnout mezi a record classrecord struct podobným rozhodnutím mezi a classstruct. Záznam termínu slouží k popisu chování, které platí pro všechny typy záznamů. Buď record struct nebo record class slouží k popisu chování, které se vztahuje pouze na struktury nebo typy tříd v uvedeném pořadí.

Poziční syntaxe pro definici vlastnosti a pole

Pomocí pozičních parametrů můžete deklarovat vlastnosti záznamu nebo inicializovat hodnoty vlastností nebo polí. Následující příklad vytvoří záznam se dvěma pozičními vlastnostmi:

public record Person(string FirstName, string LastName);

public static void Main()
{
    Person person = new("Nancy", "Davolio");
    Console.WriteLine(person);
    // output: Person { FirstName = Nancy, LastName = Davolio }
}

Pokud použijete poziční syntaxi pro definici vlastnosti, kompilátor vytvoří:

  • Veřejná vlastnost automaticky implementovaná pro každý poziční parametr zadaný v deklaraci záznamu.
    • Pro record typy a readonly record struct typy: Vlastnost pouze inicializační.
    • Pro record struct typy: Vlastnost pro čtení i zápis.
  • Primární konstruktor, jehož parametry odpovídají pozičním parametrům deklarace záznamu.
  • U typů struktury záznamů je konstruktor bez parametrů, který nastaví každé pole na výchozí hodnotu.
  • Metoda Deconstruct s parametrem out pro každý poziční parametr zadaný v deklaraci záznamu. Metoda dekonstruuje vlastnosti definované pomocí poziční syntaxe; ignoruje vlastnosti definované pomocí standardní syntaxe vlastností.

Do některého z těchto prvků můžete přidat atributy, které kompilátor vytvoří z definice záznamu. Cíl můžete přidat do libovolného atributu, který použijete u vlastností pozičního záznamu. Následující příklad platí pro System.Text.Json.Serialization.JsonPropertyNameAttribute každou vlastnost záznamu Person . Cíl property: označuje, že atribut se použije na vlastnost vygenerovanou kompilátorem. Další hodnoty mají field: použít atribut na pole a param: použít atribut na parametr.

/// <summary>
/// Person record type
/// </summary>
/// <param name="FirstName">First Name</param>
/// <param name="LastName">Last Name</param>
/// <remarks>
/// The person type is a positional record containing the
/// properties for the first and last name. Those properties
/// map to the JSON elements "firstName" and "lastName" when
/// serialized or deserialized.
/// </remarks>
public record Person([property: JsonPropertyName("firstName")] string FirstName, 
    [property: JsonPropertyName("lastName")] string LastName);

Předchozí příklad také ukazuje, jak vytvořit komentáře dokumentace XML pro záznam. Značku můžete přidat a přidat <param> dokumentaci k parametrům primárního konstruktoru.

Pokud vygenerovaná definice automaticky implementované vlastnosti není to, co chcete, můžete definovat vlastní vlastnost nebo pole se stejným názvem. Můžete například chtít změnit přístupnost nebo mutovatelnost nebo poskytnout implementaci get nebo set přístupového objektu. Pokud deklarujete člena ve zdroji, musíte ho inicializovat z pozičního parametru záznamu. Pokud je vaše vlastnost automaticky implementovaná, musíte vlastnost inicializovat. Pokud do zdroje přidáte záložní pole, musíte inicializovat backingové pole. Vygenerovaný dekonstruktor používá vaši vlastnost nebo definici pole. Například následující příklad deklaruje FirstName a LastName vlastnosti pozičního záznamu public, ale omezuje Id poziční parametr na internal. Tuto syntaxi můžete použít pro záznamy a typy struktury záznamů.

public record Person(string FirstName, string LastName, string Id)
{
    internal string Id { get; init; } = Id;
}

public static void Main()
{
    Person person = new("Nancy", "Davolio", "12345");
    Console.WriteLine(person.FirstName); //output: Nancy

}

Pokud chcete vytvořit pole místo vlastnosti, přiřaďte poziční parametr k poli, jak je znázorněno v následujícím příkladu:

public record Person(string FirstName, string LastName, string Id)
{
    internal readonly string Id = Id; // this.Id set to parameter Id
}

public static void Main()
{
    Person person = new("Nancy", "Davolio", "12345");
    Console.WriteLine(person.FirstName); //output: Nancy

}

Typ záznamu nemusí deklarovat žádné poziční vlastnosti. Můžete deklarovat záznam bez jakýchkoli pozičních vlastností a můžete deklarovat další pole a vlastnosti, jako v následujícím příkladu:

public record Person(string FirstName, string LastName)
{
    public string[] PhoneNumbers { get; init; } = [];
};

Vlastnosti, které kompilátor generuje z pozičních parametrů, jsou public. Modifikátory přístupu deklarujete u všech vlastností, které explicitně deklarujete.

Neměnitelnost

Třída poziční záznam a poziční pouze pro čtení struktura záznamu deklarují vlastnosti pouze pro inicializaci. Struktura pozičního záznamu deklaruje vlastnosti pro čtení i zápis. Můžete přepsat kteroukoli z těchto výchozích hodnot, jak je znázorněno v předchozí části.

Neměnnost může být užitečná v případě, že potřebujete typ orientovaný na data, který je bezpečný pro přístup z více vláken, nebo v závislosti na kódu hash, který zůstane stejný v tabulce hash. Neměnnost ale není vhodná pro všechny scénáře dat. Entity Framework Core například nepodporuje aktualizaci pomocí neměnných typů entit.

Inicializační vlastnosti, ať už vytvořené z pozičních parametrů (record classa readonly record struct) nebo určením init přístupových objektů, mají neměnnost. Po inicializaci nelze změnit hodnotu vlastností typu hodnoty ani odkaz na vlastnosti typu odkazu. Data, na která odkazuje vlastnost typu odkaz, je však možné změnit. Následující příklad ukazuje, že obsah neměnné vlastnosti typu odkazu (v tomto případě pole) je proměnlivý:

public record Person(string FirstName, string LastName, string[] PhoneNumbers);

public static void Main()
{
    Person person = new("Nancy", "Davolio", new string[1] { "555-1234" });
    Console.WriteLine(person.PhoneNumbers[0]); // output: 555-1234

    person.PhoneNumbers[0] = "555-6789";
    Console.WriteLine(person.PhoneNumbers[0]); // output: 555-6789
}

Funkce, které jsou jedinečné pro typy záznamů, jsou implementovány syntetizovanými metodami kompilátoru a žádná z těchto metod nezhroužuje neměnnost úpravou stavu objektu. Pokud není uvedeno, syntetizované metody jsou generovány pro record, record structa readonly record struct deklarace.

Rovnost hodnot

Pokud nepřepíšete nebo nenahrazujete metody rovnosti, typ, který deklarujete, určuje, jak je definována rovnost:

  • Pro class typy jsou dva objekty stejné, pokud odkazují na stejný objekt v paměti.
  • Pro struct typy jsou dva objekty stejné, pokud jsou stejného typu a ukládají stejné hodnoty.
  • U typů s modifikátorem record (record class, record structa readonly record struct) jsou dva objekty stejné, pokud jsou stejného typu a ukládají stejné hodnoty.

Definice rovnosti pro a record struct je stejná jako u .struct Rozdíl je v tom, že implementace structje v ValueType.Equals(Object) a spoléhá na reflexi. U záznamů je implementace syntetizována kompilátorem a používá deklarované datové členy.

U některých datových modelů je vyžadována rovnost odkazů. Například Entity Framework Core závisí na rovnosti odkazů, aby se zajistilo, že používá pouze jednu instanci typu entity pro to, co je koncepčně jedna entita. Z tohoto důvodu nejsou záznamy a struktury záznamů vhodné pro použití jako typy entit v Entity Framework Core.

Následující příklad znázorňuje rovnost hodnot typů záznamů:

public record Person(string FirstName, string LastName, string[] PhoneNumbers);

public static void Main()
{
    var phoneNumbers = new string[2];
    Person person1 = new("Nancy", "Davolio", phoneNumbers);
    Person person2 = new("Nancy", "Davolio", phoneNumbers);
    Console.WriteLine(person1 == person2); // output: True

    person1.PhoneNumbers[0] = "555-1234";
    Console.WriteLine(person1 == person2); // output: True

    Console.WriteLine(ReferenceEquals(person1, person2)); // output: False
}

K implementaci rovnosti hodnot kompilátor syntetizuje několik metod, včetně:

  • Přepsání .Object.Equals(Object) Pokud je přepsání deklarováno explicitně, jedná se o chybu.

    Tato metoda se používá jako základ pro statickou metodu Object.Equals(Object, Object) , pokud oba parametry nemají hodnotu null.

  • A virtual, nebo sealed, Equals(R? other) kde R je typ záznamu. Tato metoda implementuje IEquatable<T>. Tuto metodu lze deklarovat explicitně.

  • Je-li typ záznamu odvozen od základního typu Basezáznamu , Equals(Base? other). Pokud je přepsání deklarováno explicitně, jedná se o chybu. Pokud zadáte vlastní implementaci Equals(R? other), uveďte také implementaci GetHashCode .

  • Přepsání .Object.GetHashCode() Tuto metodu lze deklarovat explicitně.

  • Přepsání operátorů == a !=. Jedná se o chybu, pokud jsou operátory deklarovány explicitně.

  • Pokud je typ záznamu odvozen od základního typu záznamu, protected override Type EqualityContract { get; };. Tuto vlastnost lze deklarovat explicitně. Další informace naleznete v tématu Rovnost v hierarchiích dědičnosti.

Kompilátor syntetizuje metodu, pokud typ záznamu má metodu, která odpovídá podpisu syntetizované metody, která může být deklarována explicitně.

Nedestruktivní mutaci

Pokud potřebujete zkopírovat instanci s některými úpravami, můžete pomocí výrazu with dosáhnout nedestruktivní mutaci. Výraz with vytvoří novou instanci záznamu, která je kopií existující instance záznamu se zadanými vlastnostmi a poli upravenými. Syntaxe inicializátoru objektů slouží k určení hodnot, které se mají změnit, jak je znázorněno v následujícím příkladu:

public record Person(string FirstName, string LastName)
{
    public string[] PhoneNumbers { get; init; }
}

public static void Main()
{
    Person person1 = new("Nancy", "Davolio") { PhoneNumbers = new string[1] };
    Console.WriteLine(person1);
    // output: Person { FirstName = Nancy, LastName = Davolio, PhoneNumbers = System.String[] }

    Person person2 = person1 with { FirstName = "John" };
    Console.WriteLine(person2);
    // output: Person { FirstName = John, LastName = Davolio, PhoneNumbers = System.String[] }
    Console.WriteLine(person1 == person2); // output: False

    person2 = person1 with { PhoneNumbers = new string[1] };
    Console.WriteLine(person2);
    // output: Person { FirstName = Nancy, LastName = Davolio, PhoneNumbers = System.String[] }
    Console.WriteLine(person1 == person2); // output: False

    person2 = person1 with { };
    Console.WriteLine(person1 == person2); // output: True
}

Výraz with může nastavit poziční vlastnosti nebo vlastnosti vytvořené pomocí standardní syntaxe vlastností. Explicitně deklarované vlastnosti musí mít ve výrazu init změněný set objekt nebo with přístup.

Výsledkem výrazu with je mělká kopie, což znamená, že pro vlastnost odkazu se zkopíruje pouze odkaz na instanci. Původní záznam i kopie končí odkazem na stejnou instanci.

K implementaci této funkce pro record class typy kompilátor syntetizuje klonovací metodu a konstruktor kopírování. Metoda virtuálního klonu vrátí nový záznam inicializovaný konstruktorem kopírování. Při použití with výrazu kompilátor vytvoří kód, který volá metodu klonu a potom nastaví vlastnosti zadané ve výrazu with .

Pokud potřebujete jiné chování kopírování, můžete napsat vlastní konstruktor kopírování do .record class Pokud to uděláte, kompilátor ho syntetizuje. Vytvořte konstruktor private , pokud je sealedzáznam , jinak ho protectednastavte . Kompilátor syntetizuje konstruktor kopírování pro record struct typy. Můžete ho napsat, ale kompilátor negeneruje volání pro with výrazy. Hodnoty se record struct zkopírují při přiřazení.

Klonovací metodu nemůžete přepsat a nemůžete vytvořit člena pojmenovaného Clone v žádném typu záznamu. Skutečný název klonovací metody je vygenerován kompilátorem.

Integrované formátování pro zobrazení

Typy záznamů mají metodu vygenerovanou ToString kompilátorem, která zobrazuje názvy a hodnoty veřejných vlastností a polí. Metoda ToString vrátí řetězec následujícího formátu:

<název typu záznamu { >název<> vlastnosti = <hodnota>, <název> vlastnosti = <hodnota>, ...}

Řetězec vytištěný <value> pro je řetězec vrácený ToString() typem vlastnosti. V následujícím příkladu ChildNames je , System.Arraykde ToString vrátí System.String[]:

Person { FirstName = Nancy, LastName = Davolio, ChildNames = System.String[] }

K implementaci této funkce kompilátor v record class typech syntetizuje virtuální PrintMembers metodu a přepsání ToString . V record struct typech je privatetento člen . Přepsání ToString vytvoří StringBuilder objekt s názvem typu následovaným levou závorkou. PrintMembers Volá přidání názvů a hodnot vlastností a pak přidá pravou hranaté závorku. Následující příklad ukazuje kód podobný syntetizovanému přepsání obsahuje:

public override string ToString()
{
    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.Append("Teacher"); // type name
    stringBuilder.Append(" { ");
    if (PrintMembers(stringBuilder))
    {
        stringBuilder.Append(" ");
    }
    stringBuilder.Append("}");
    return stringBuilder.ToString();
}

Můžete zadat vlastní implementaci PrintMembers nebo přepsání ToString . Příklady jsou uvedeny ve formátování v oddílu PrintMembers odvozených záznamů dále v tomto článku. Vaše implementace ToString může zahrnovat modifikátor sealed, který brání kompilátoru v syntetizaci implementace ToString pro všechny odvozené záznamy. Můžete vytvořit konzistentní řetězcovou reprezentaci v celé hierarchii record typů. (Odvozené záznamy mají stále vygenerovanou metodu PrintMembers pro všechny odvozené vlastnosti.)

Dědičnost

Tato část se vztahuje pouze na record class typy.

Záznam může dědit z jiného záznamu. Záznam však nemůže dědit z třídy a třída nemůže dědit ze záznamu.

Poziční parametry v odvozených typech záznamů

Odvozený záznam deklaruje poziční parametry pro všechny parametry v primárním konstruktoru základního záznamu. Základní záznam deklaruje a inicializuje tyto vlastnosti. Odvozený záznam je neskryje, ale vytvoří a inicializuje vlastnosti parametrů, které nejsou deklarovány v základním záznamu.

Následující příklad znázorňuje dědičnost se syntaxí poziční vlastnosti:

public abstract record Person(string FirstName, string LastName);
public record Teacher(string FirstName, string LastName, int Grade)
    : Person(FirstName, LastName);
public static void Main()
{
    Person teacher = new Teacher("Nancy", "Davolio", 3);
    Console.WriteLine(teacher);
    // output: Teacher { FirstName = Nancy, LastName = Davolio, Grade = 3 }
}

Rovnost v hierarchiích dědičnosti

Tato část se týká record class typů, ale ne record struct typů. Aby byly dvě proměnné záznamů stejné, musí být typ běhu roven. Typy obsahujících proměnných se můžou lišit. Porovnání zděděné rovnosti je znázorněno v následujícím příkladu kódu:

public abstract record Person(string FirstName, string LastName);
public record Teacher(string FirstName, string LastName, int Grade)
    : Person(FirstName, LastName);
public record Student(string FirstName, string LastName, int Grade)
    : Person(FirstName, LastName);
public static void Main()
{
    Person teacher = new Teacher("Nancy", "Davolio", 3);
    Person student = new Student("Nancy", "Davolio", 3);
    Console.WriteLine(teacher == student); // output: False

    Student student2 = new Student("Nancy", "Davolio", 3);
    Console.WriteLine(student2 == student); // output: True
}

V příkladu jsou všechny proměnné deklarovány jako Person, i když je instance odvozený typ buď Student nebo Teacher. Instance mají stejné vlastnosti a stejné hodnoty vlastností. I student == teacher když jsou Falseobě proměnné typu -type, a Person vracístudent == student2, i když jedna je proměnná True a jedna je proměnnáPerson.Student Test rovnosti závisí na typu modulu runtime skutečného objektu, nikoli deklarovaného typu proměnné.

K implementaci tohoto chování kompilátor syntetizuje EqualityContract vlastnost, která vrací Type objekt, který odpovídá typu záznamu. Umožňuje EqualityContract metodám rovnosti porovnat typ modulu runtime objektů při kontrole rovnosti. Pokud je objectzákladním typem záznamu , tato vlastnost je virtual. Pokud je základním typem jiný typ záznamu, je tato vlastnost přepsána. Pokud je sealedtyp záznamu , tato vlastnost je efektivní sealed , protože typ je sealed.

Když kód porovná dvě instance odvozeného typu, syntetizované metody rovnosti zkontrolují všechny datové členy základního a odvozeného typu rovnosti. Syntetizovaná GetHashCode metoda používá metodu GetHashCode ze všech datových členů deklarovaných v základním typu a odvozeného typu záznamu. Datové členy record zahrnutí všech deklarovaných polí a pole syntetizovaného kompilátoru pro všechny automaticky implementované vlastnosti.

with výrazy v odvozených záznamech

Výsledek výrazu with má stejný typ za běhu jako operand výrazu. Zkopírují se všechny vlastnosti typu runtime, ale můžete nastavit pouze vlastnosti typu kompilace, jak ukazuje následující příklad:

public record Point(int X, int Y)
{
    public int Zbase { get; set; }
};
public record NamedPoint(string Name, int X, int Y) : Point(X, Y)
{
    public int Zderived { get; set; }
};

public static void Main()
{
    Point p1 = new NamedPoint("A", 1, 2) { Zbase = 3, Zderived = 4 };

    Point p2 = p1 with { X = 5, Y = 6, Zbase = 7 }; // Can't set Name or Zderived
    Console.WriteLine(p2 is NamedPoint);  // output: True
    Console.WriteLine(p2);
    // output: NamedPoint { X = 5, Y = 6, Zbase = 7, Name = A, Zderived = 4 }

    Point p3 = (NamedPoint)p1 with { Name = "B", X = 5, Y = 6, Zbase = 7, Zderived = 8 };
    Console.WriteLine(p3);
    // output: NamedPoint { X = 5, Y = 6, Zbase = 7, Name = B, Zderived = 8 }
}

PrintMembers formátování v odvozených záznamech

Syntetizovaná PrintMembers metoda odvozeného typu záznamu volá základní implementaci. Výsledkem je, že do výstupu ToString jsou zahrnuty všechny veřejné vlastnosti a pole odvozených i základních typů, jak je znázorněno v následujícím příkladu:

public abstract record Person(string FirstName, string LastName);
public record Teacher(string FirstName, string LastName, int Grade)
    : Person(FirstName, LastName);
public record Student(string FirstName, string LastName, int Grade)
    : Person(FirstName, LastName);

public static void Main()
{
    Person teacher = new Teacher("Nancy", "Davolio", 3);
    Console.WriteLine(teacher);
    // output: Teacher { FirstName = Nancy, LastName = Davolio, Grade = 3 }
}

Můžete zadat vlastní implementaci PrintMembers metody. Pokud to uděláte, použijte následující podpis:

  • Pro záznam odvozený ze záznamu sealed (deklaruje základní záznam): object;private bool PrintMembers(StringBuilder builder)
  • sealed Pro záznam, který je odvozen z jiného záznamu (všimněte si, že uzavřený typ je sealed, takže metoda je efektivní sealed): protected override bool PrintMembers(StringBuilder builder);
  • Pro záznam, který není sealed a odvozuje z objektu: protected virtual bool PrintMembers(StringBuilder builder);
  • Pro záznam, který není sealed a odvozen z jiného záznamu: protected override bool PrintMembers(StringBuilder builder);

Tady je příklad kódu, který nahrazuje syntetizované PrintMembers metody, jeden pro typ záznamu odvozený z objektu a jeden pro typ záznamu, který je odvozen od jiného záznamu:

public abstract record Person(string FirstName, string LastName, string[] PhoneNumbers)
{
    protected virtual bool PrintMembers(StringBuilder stringBuilder)
    {
        stringBuilder.Append($"FirstName = {FirstName}, LastName = {LastName}, ");
        stringBuilder.Append($"PhoneNumber1 = {PhoneNumbers[0]}, PhoneNumber2 = {PhoneNumbers[1]}");
        return true;
    }
}

public record Teacher(string FirstName, string LastName, string[] PhoneNumbers, int Grade)
    : Person(FirstName, LastName, PhoneNumbers)
{
    protected override bool PrintMembers(StringBuilder stringBuilder)
    {
        if (base.PrintMembers(stringBuilder))
        {
            stringBuilder.Append(", ");
        };
        stringBuilder.Append($"Grade = {Grade}");
        return true;
    }
};

public static void Main()
{
    Person teacher = new Teacher("Nancy", "Davolio", new string[2] { "555-1234", "555-6789" }, 3);
    Console.WriteLine(teacher);
    // output: Teacher { FirstName = Nancy, LastName = Davolio, PhoneNumber1 = 555-1234, PhoneNumber2 = 555-6789, Grade = 3 }
}

Poznámka:

Kompilátor generuje PrintMembers v odvozených záznamech, i když základní záznam zapečetil metodu ToString. Můžete také vytvořit vlastní implementaci PrintMembers.

Chování dekonstruktoru v odvozených záznamech

Metoda Deconstruct odvozeného záznamu vrátí hodnoty všech pozičních vlastností typu kompilace. Pokud je typ proměnné základním záznamem, jsou dekonstruovány pouze vlastnosti základního záznamu, pokud objekt není přetypován na odvozený typ. Následující příklad ukazuje volání dekonstruktor na odvozený záznam.

public abstract record Person(string FirstName, string LastName);
public record Teacher(string FirstName, string LastName, int Grade)
    : Person(FirstName, LastName);
public record Student(string FirstName, string LastName, int Grade)
    : Person(FirstName, LastName);

public static void Main()
{
    Person teacher = new Teacher("Nancy", "Davolio", 3);
    var (firstName, lastName) = teacher; // Doesn't deconstruct Grade
    Console.WriteLine($"{firstName}, {lastName}");// output: Nancy, Davolio

    var (fName, lName, grade) = (Teacher)teacher;
    Console.WriteLine($"{fName}, {lName}, {grade}");// output: Nancy, Davolio, 3
}

Obecná omezení

Klíčové record slovo je modifikátor pro typ class nebo typ struct . Přidání modifikátoru record zahrnuje chování popsané výše v tomto článku. Neexistuje žádné obecné omezení, které vyžaduje, aby typ byl záznamem. A record class splňuje class omezení. A record struct splňuje struct omezení. Další informace naleznete v tématu Omezení parametrů typu.

specifikace jazyka C#

Další informace najdete v části Třídy specifikace jazyka C#.

Další informace o těchto funkcích najdete v následujících poznámkách k návrhu funkcí:

Viz také