enum, struct અને class વચ્ચે શું તફાવત છે?

Question

Accepted Answer

આ C# માં ત્રણ અલગ અલગ પ્રકારના types છે: **enum** (constant values નો નામવાળો સમૂહ), **struct** (નાના ડેટા માટે value type), અને **class** (objects માટે reference type). યોગ્ય પસંદગી તમે જે ડેટા અને વર્તણૂક મોડેલ કર્યું છે તેના પર નির્ભર છે.

## enum — constants નો નામવાળો સમૂહ

```csharp
public enum Status { Active, Inactive, Pending }   // named constants (Active=0, ...)

Status s = Status.Active;
if (s == Status.Active) { }                         // type-safe constants

public enum Permissions { Read = 1, Write = 2, Execute = 4 }   // [Flags] for bit flags
```

એક **enum** નામવાળા મૂલ્યોનો નિશ્ચિત સમૂહ વ્યાખ્યાયિત કરે છે — states, roles, અથવા options જેવી વસ્તુઓ માટે type-safe constants (magic numbers/strings ને બદલે). તે પૂર્ણાંક દ્વારા સમર્થિત value type છે.

## struct — નાના ડેટા માટે value type

```csharp
public struct Point          // VALUE type — copied by value, no heap allocation
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}
Point p1 = new(1, 2);
Point p2 = p1;               // COPIES the whole struct (independent)
```

એક **struct** value type છે — inline માં સંગ્રહિત (ઘણીવાર stack પર), value દ્વારા નકલ કરવામાં આવે છે, કોઈ heap allocation નથી. **નાનું, immutable, data-like** મૂલ્યો (coordinates, money, એક તારીખ) માટે શ્રેષ્ઠ છે જ્યાં value semantics અને heap allocation ટાળવું પ્રદર્શન માટે મદદ કરે છે.

## class — objects માટે reference type

```csharp
public class User            // REFERENCE type — on the heap, copied by reference
{
    public string Name { get; set; }
    public void DoWork() { }   // rich behavior
}
User u1 = new() { Name = "Ann" };
User u2 = u1;                // both reference the SAME object
```

એક **class** reference type છે — heap પર, reference દ્વારા નકલ કરવામાં આવે છે (શેર કરવામાં આવે છે), inheritance અને સમૃદ્ધ વર્તણૂક સમર્થિત કરે છે. મોટાભાગના objects માટે ડિફોલ્ટ પસંદગી જેમાં identity, behavior, અને mutable state હો.

## કયો કબ્જ કરવો તે વખતે કરો

```text
enum   → a fixed set of named constants (states, roles, options)
struct → small, immutable data values; value semantics; avoid heap allocation
         (keep small — large structs are costly to copy)
class  → most objects: identity, behavior, inheritance, mutable/larger state (the default)
```

## શા માટે તે મહત્વપૂર્ણ છે

યોગ્ય પ્રકારના type — enum, struct, અથવા class — પસંદ કરવું એક મૌલિક C# ડિઝાઇન નિર્ણય છે જે correctness, semantics, અને performance ને અસર કરે છે, તેથી તફાવતોને સમજવું મહત્વપૂર્ણ છે. **Enums** type-safe નામવાળા constants પ્રદાન કરે છે (states, roles, options માટે), ભૂલ-પ્રવણ magic numbers અથવા strings કરતાં ઘણું બધું વધુ સારું છે — એક સામાન્ય, મૂલ્યવાન મોડેલિંગ સાધન.

**Struct vs class** તફાવત ખાસ મહત્વપૂર્ણ છે કારણ કે તે **value vs reference semantics** નક્કી કરે છે: structs value types છે (value દ્વારા નકલ કરવામાં આવે છે, inline સંગ્રહિત, કોઈ heap allocation નથી) જે નાનું immutable ડેટા મૂલ્યો માટે યોગ્ય છે જ્યાં value semantics અને ઓછો allocation પ્રદર્શન માટે મદદ કરે છે, જ્યારે classes reference types છે (reference દ્વારા શેર કરવામાં આવે છે, heap-allocated, inheritance અને સમૃદ્ધ વર્તણૂક સમર્થિત કરે છે) — મોટાભાગના objects માટે ડિફોલ્ટ જેમાં identity અને behavior હો.

યોગ્ય પસંદગી કરવાની નિષ્ફળતા વાસ્તવિક પરિણામ છે: એક મોટું struct નકલ કરવામાં ખર્ચપ્રોતી છે, અને structs નો ઉપયોગ કરવો જ્યાં reference semantics અપેક્ષિત હોય (અથવા તેનાથી વિપરીત) સૂક્ષ્મ bugs પેદા કરે છે.

કયો દરેક ને બાદ કરવો તે સમજવું — enum fixed constant sets માટે, struct નાનું ડેટા-like મૂલ્યો માટે (નાના રાખવામાં આવે), class મોટાભાગના objects માટે (ડિફોલ્ટ) — અને value-vs-reference સૂચિતાર્થ જરૂરી જ્ઞાન છે C# માં ડેટા સાચી રીતે અને કાર્યક્ષમતાથી મોડેલ કરવા માટે.

ચૂંકી આ પસંદગી દરેક વખતે દેખાય છે જ્યારે તમે type વ્યાખ્યાયિત કરો, અને જ્યાં value/reference તફાવત C# ના સોથી વધુ વર્તણૂક પર આધાર રાખે છે, enums, structs, અને classes ના તફાવતો અને યોગ્ય ઉપયોગ જાણવું મૂળ, વારવાર-સંબંધિત જ્ઞાન છે અને C# ના type system ના સમજણને પ્રતિબિંબિત કરતી સામાન્ય interview topic છે.