C# இல் records என்றால் என்ன?

Question

Accepted Answer

**Records** (C# 9+) என்பவை முதன்மையாக **மாறாத தரவு கொண்டு செல்லும்** வகைகளையும் **மதிப்பு-அடிப்படையிலான சமानता**யையும் வரையறுக்க ஒரு சுருக்கமான வழி ஆகும். இவை boilerplate (constructor, equality, `ToString`, முதலியவை) ஐ தானாகவே உருவாக்குகின்றன, DTOs, domain values, மற்றும் தரவு மாடலிங்கிற்கு இவை இலட்சணமாக உள்ளன.

## Record வரையறுத்தல் (positional syntax)

```csharp
// one line generates: constructor, properties, equality, ToString, deconstruction
public record Person(string Name, int Age);

var p1 = new Person("Ann", 30);
p1.Name;                          // "Ann" (read-only property)
Console.WriteLine(p1);             // Person { Name = Ann, Age = 30 } — ToString generated
```

Positional syntax `record Person(string Name, int Age)` - எல்லாவற்றையும் உருவாக்குகிறது — properties, constructor, `ToString`, equality, deconstruction — regular class க்கு தேவையான boilerplate ஐ நீக்குகிறது.

## மதிப்பு-அடிப்படையிலான சமानता (classes இலிருந்து முக்கிய வேறுபாடு)

```csharp
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 **மதிப்பு**க்கு ஏற்ப ஒப்பிடுகின்றன — ஒரே property values உடைய இரண்டு records சமம். இது தரவு objects க்கு நீங்கள் விரும்புவதே.

## மாறாமை மற்றும் non-destructive mutation (with)

```csharp
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 இயல்பாகவே மாறாதவை, மற்றும் **`with` expression** ஒரு மாற்றப்பட்ட நகலை உருவாக்குகிறது (non-destructive mutation) — மாறாத தரவைக் கொண்டு வேலை செய்வதற்கு இலட்சணம்.

## record class vs record struct

```csharp
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 என்பது ஒரு முக்கியமான நவீன C# வசதி (C# 9+) ஆகும் மாறாத தரவு வகைகளை வரையறுப்பதை சுருக்கமாகவும் சரியாகவும் செய்கிறது, எனவே அவற்றைப் புரிந்துகொள்வது நவீன C# development க்கு மதிப்புள்ளது.

அவற்றின் முக்கிய நன்மைகள் உண்மையான தேவைகளை பூரணம் செய்கின்றன: அவை **boilerplate ஐ நீக்குகின்றன** (constructors, properties, `ToString`, equality, மற்றும் deconstruction ஐ ஒரு-வரி வாக்கியத்திலிருந்து தானாகவே உருவாக்குகின்றன — regular class தேவைப்படும் பெரிய குறியீட்டுக்கு ஏற்ப), மற்றும் அவை **மதிப்பு-அடிப்படையிலான சமानத்தை** வழங்குகின்றன (சமம் properties உடைய இரண்டு records சமம், classes போல் அல்ல যவை reference மூலம் ஒப்பிடுகின்றன) — இது தரவு objects, DTOs, மற்றும் domain values க்கு நீங்கள் விரும்புவதே, மற்றும் classes இயல்பாகவே இதை தவறாக செய்கின்றன.

Records இருக்கின்றன **மாறாதவை இயல்பாகவே** `with` expression ஆனது優雅 non-destructive mutation (மாற்றப்பட்ட நகல்கள் உருவாக்குகிறது), immutable, functional style ஐ ஆதரிக்கிறது இது பாதுகாப்பான, மிக வேண்டுகோள் யோக்கியமான குறியீட்டிற்கு போக்கு ஆகிறது.

Records புரிந்துகொள்வது — சுருக்கமான syntax, value equality, immutability with `with`, மற்றும் record structs — நவீன C# எழுதுவதற்கு மதிப்புள்ளது, அவை தரவை மாடல் செய்வதற்கு idiomatic வழி ஆகும் (DTOs, API models, value objects, immutable state) மற்றும் தற்போதைய codebases இல் பரவலாக பயன்படுத்தப்படுகிறது.

OK Record (immutable data with value semantics) க்கு எப்போது பயன்படுத்த வேண்டும் என்பது தெரிந்துகொள்வது class க்கு (mutable objects with identity மற்றும் rich behavior) விரோதமாக C# நவீனத்தைக் கொண்டு fluency ஐ பிரதிபலிக்கிறது.

Records தரவு மாடலிங் வியக்கமாக எளிமையாக்குகிறது சரியான equality மற்றும் மாறாமை வழங்க என்று — பொதுவான தேவைகள் முன் tedious மற்றும் error-prone இருந்த — அவை ஒரு முக்கியமான, frequently-used வசதி நவீன, clean C# குறியீட்டின் hallmark ஆகும்.