Records (C# 9+) არის concise გზა სახელოვანი ტიპების დასაწერად, რომლებიც ძირითადად immutable data carriers არიან value-based equality-თან. ისინი auto-generate აკეთებენ boilerplate-ს (constructor, equality, ToString, და ა.შ.), რაც მათ ideal აკეთებს DTOs, domain values და data modeling-ისთვის.
;
p1 = Person(, );
p1.Name;
Console.WriteLine(p1);
Positional syntax record Person(string Name, int Age) აგენერირებს ყველაფერს — properties, constructor, ToString, equality, deconstruction — და აღმოფხვრის boilerplate-ს, რომელიც regular class-ი სჭირდება.
var a = new Person("Ann", 30);
var b = new Person("Ann", 30);
a == b; // TRUE — records compare by VALUE (all properties equal)
// (a regular class would be FALSE here — classes compare by reference)
Classes-ისგან განსხვავებით (რომლებიც ადარებენ reference identity-ს), records ადარებენ value-ს — ორი record, რომელსაც აქვს ერთი და იგივე property values, ტოლი არია. ეს არის ზუსტად ის, რაც გსურთ data objects-ისთვის.
public record Person(string Name, int Age); // properties are init-only (immutable)
var p1 = new Person("Ann", 30);
var p2 = p1 with { Age = 31 }; // `with` creates a COPY with some properties changed
// p1 unchanged (immutable); p2 = Person { Name = Ann, Age = 31 }
Records არიან immutable by default, და with expression აქმნის modified copy-ს (non-destructive mutation) — ideal immutable data-სთან მუშაობისთვის.
public record class Ref(int X); // a reference type (default) with value equality
public record struct Val(int X); // a VALUE type record (C# 10)
Records არიან მნიშვნელოვანი modern C# feature (C# 9+), რომელიც immutable data types-ის დესკრიბირებას აკეთებს concise და correct, ამიტომ მათი გაგება ღირებულია modern C# development-ისთვის.
თავიანთი key benefits მოაგვარებენ real needs: ისინი აღმოფხვრიან boilerplate-ს (auto-generate კონსტრუქტორებს, properties, ToString, equality და deconstruction-ს ერთი ხაზის დეკლარაციიდან — იმ მნიშვნელოვან კოდის წინააღმდეგ, რომელიც regular class-ი მოითხოვს), და მოაწვდიან value-based equality-ს (ორი record ტოლი properties-თან ტოლი არია, classes-ის განსხვავებით, რომლებიც ადარებენ reference-ს) — რაც არის ზუსტად ის behavior, რაც გსურთ data objects, DTOs და domain values-ისთვის, და რაც classes-ი არასწორად აკეთებენ by default.
Records არიან ასევე immutable by default elegant with expression-თან non-destructive mutation-ისთვის (modified copies-ის შექმნა), რომელიც მხარს უჭერს immutable, functional style-ს, რომელიც სულ უფრო უპირატესი ხდება safer, more predictable code-ის জন্য.
Records-ის გაგება — concise syntax, value equality, immutability with-თან, და record structs — ღირებულია clean modern C#-ის დასაწერად, რადგან ისინი არიან idiomatic გზა data-ს მოდელირებისთვის (DTOs, API models, value objects, immutable state) და ფართოდ გამოიყენება current codebase-ებში.
ვიცოდეთ, როდის გამოიყენოთ record (immutable data value semantics-თან) versus class (mutable objects with identity and rich behavior) ასახავს fluency-ს modern C#-ში.
ვინაიდან records დრამატულად გამარტივებენ data modeling-ს სწორი equality და immutability-ს მიწოდებისას — common needs, რომლებიც tedious და error-prone იყვნენ აქამდე — ისინი არიან მნიშვნელოვანი, frequently-used feature, რომელიც არის modern, clean C# code-ის hallmark.