C# માં records શું છે?

Question

Accepted Answer

**Records** (C# 9+) એ types વ્યાખ્યાયિત કરવાનો એક સંક્ષિપ્ત રસ્તો છે જે મુખ્યત્વે **અપરિવર્તનીય ડેટા વાહક** અને **મૂલ્ય-આધારિત સમાનતા** સાથે હોય છે. તેઓ 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 — جो નિયમિત 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 મૂલ્યો સાથે બે 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** એક modified copy બનાવે છે (non-destructive mutation) — અપરિવર્તનીય ડેટા સાથે કામ કરવા માટે આદર્શ છે.

## record class વિરુદ્ધ 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# feature (C# 9+) છે જે અપરિવર્તનીય ડેટા types વ્યાખ્યાયિત કરવાને સંક્ષિપ્ત અને સાચું બનાવે છે, તેથી તેમને સમજવું આધુનિક C# વિકાસ માટે મૂલ્યવાન છે.

તેમના મુખ્ય લાભો વાસ્તવિક જરૂરિયાતોને સંબોધિત કરે છે: તેઓ **boilerplate ને દૂર કરે છે** (constructors, properties, `ToString`, equality, અને deconstruction ને એક-લાઇન declaration થી auto-generate કરે છે — વિરુદ્ધ નિયમિત class જે સમર્થક કોડ જરૂર છે), અને તેઓ **મૂલ્ય-આધારિત સમાનતા** પ્રદાન કરે છે (બે records સમાન properties સાથે સમાન છે, classes જેમ નથી જે reference દ્વારા સરખામણી કરે છે) — જે બરાબર તે વર્તન છે જે તમે ડેટા objects, DTOs, અને domain values માટે ઇચ્છો છો, અને જે classes ડિફોલ્ટ રીતે ખોટું કરે છે.

Records પણ **અપરિવર્તનીય ડિફોલ્ટ રીતે** છે elegant **`with` expression** સાથે non-destructive mutation (modified copies બનાવવા માટે), અપરિવર્તનીય, functional style સમર્થન કરે છે જે સુરક્ષિત, વધુ અનુમાનપાત્ર કોડ માટે વધુ જરૂર છે.

Records ને સમજવું — સંક્ષિપ્ત syntax, value equality, immutability with `with`, અને record structs — સ્વચ્છ આધુનિક C# લખવા માટે મૂલ્યવાન છે, કારણ કે તેઓ ડેટા મોડેલ કરવાનો idiomatic રસ્તો છે (DTOs, API models, value objects, immutable state) અને વર્તમાન codebases માં વ્યાપક રીતે વપરાય છે.

જ્ઞાન જ્યારે record (immutable data with value semantics) વિરુદ્ધ class (mutable objects with identity અને rich behavior) વાપરવો તે આધુનિક C# સાથે fluency પ્રતિબિંબિત કરે છે.

Records નાટકીય રીતે ડેટા મોડેલિંગ સરળ બનાવે છે જ્યારે સાચી સમાનતા અને અપરિવર્તનીયતા પ્રદાન કરે છે — સામાન્ય જરૂરિયાતો જે પહેલાં કંટાળાજનક અને error-prone હતી — તેઓ એક મહત્વપૂર્ણ, વારંવાર-વપરાયેલો feature છે જે આધુનિક, સ્વચ્છ C# કોડનું hallmark છે.