enum, struct మరియు class మధ్య తేడా ఏమిటి?

Question

Accepted Answer

ఇవి C#లో మూడు విభిన్న రకాల రకాలు: **enum** (నామకరణ చేయబడిన స్థిరాంకాల సమితి), **struct** (చిన్న డేటా కోసం విలువ రకం), మరియు **class** (వస్తువుల కోసం సూచన రకం). సరిగ్గా ఎంచుకోవడం మీరు మోడలింగ చేస్తున్న డేటా మరియు ప్రవర్తనపై ఆధారపడి ఉంటుంది.

## enum — స్థిరాంకాల యొక్క నామకరణ చేయబడిన సమితి

```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** స్థిర నామకరణ చేయబడిన విలువల సమితిని నిర్వచిస్తుంది — రాష్ట్రాలు, పాత్రలు, లేదా ఎంపికల (మ్యాజిక్ సంఖ్యలు/స్ట్రింగ్‌లను భర్తీ చేసేవి) వంటి విషయాల కోసం టైప్-సేఫ్ స్థిరాంకాలు. ఇది ఒక పూర్ణాంకం ద్వారా సమర్థితమైన విలువ రకం.

## struct — చిన్న డేటా కోసం విలువ రకం

```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** విలువ రకం — ఇన్‌లైన్‌లో నిల్వ చేయబడుతుంది (తరచుగా స్టాక్‌పై), విలువ ద్వారా నకిలీ చేయబడుతుంది, కుప్ప కేటాయింపు లేదు. **చిన్న, మార్పులేని, డేటా-సంబంధిత** విలువల (కోఆర్డినేట్‌లు, డబ్బు, తేదీ) కోసం ఉత్తమం, ఇక్కడ విలువ సెమాంటిక్‌లు మరియు కుప్ప కేటాయింపు నివారణ పనితీరుకు సహాయపడుతుంది.

## class — వస్తువుల కోసం సూచన రకం

```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** సూచన రకం — కుప్పపై, సూచన ద్వారా నకిలీ చేయబడుతుంది (భాగస్వామ్య), వారసత్వం మరియు సমృద్ధ ప్రవర్తనకు సమర్థన ఇస్తుంది. గుర్తింపు, ప్రవర్తన, మరియు మార్పులేని స్థితితో కూడిన చిత్రత్యాఖ్యతకు డిఫాల్ట్ ఎంపిక.

## ఎది ఎప్పుడు ఉపయోగించాలో

```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)
```

## ఇది ఎందుకు ముఖ్యమైనది

సరిగ్గా రకం — enum, struct, లేదా class — ఎంచుకోవడం ప్రాథమిక C# డిజైన్ నిర్ణయం, ఇది సరిసామ్యత, సెమాంటిక్‌లు, మరియు పనితీరును ప్రభావితం చేస్తుంది, కాబట్టి తేడాలను అర్థం చేసుకోవడం ముఖ్యమైనది. **Enums** టైప్-సేఫ్ నామకరణ చేయబడిన స్థిరాంకాలను (రాష్ట్రాలు, పాత్రలు, ఎంపికల కోసం) అందిస్తాయి, లోపం-నిండిన మ్యాజిక్ సంఖ్యలు లేదా స్ట్రింగ్‌ల కంటే చాలా మెరుగైనవి — ఒక సాధారణ, విలువైన మోడలింగ సాధనం.

**struct vs class** వ్యత్యాసం ప్రత్యేకంగా ముఖ్యమైనది ఎందుకంటే ఇది **విలువ vs సూచన సెమాంటిక్‌లను** నిర్ణయిస్తుంది: structs విలువ రకాలు (విలువ ద్వారా నకిలీ చేయబడిన, ఇన్‌లైన్‌లో నిల్వ చేయబడిన, కుప్ప కేటాయింపు లేదు) చిన్న మార్పులేని డేటా విలువలకు అనుకూలమైనవి ఇక్కడ విలువ సెమాంటిక్‌లు మరియు నిరోధించిన కేటాయింపు పనితీరుకు సహాయపడుతుంది, అయితే classes సూచన రకాలు (సూచన ద్వారా భాగస్వామ్య, కుప్ప-కేటాయించిన, వారసత్వం మరియు సమృద్ధ ప్రవర్తనకు సమర్థన) — చిత్రత్యాఖ్యత మరియు ప్రవర్తన ఉన్న చిత్రత్యాఖ్యత వస్తువుల కోసం డిఫాల్ట్.

నిర్ణయం తప్పుగా చేయడం నిజమైన పరిణామాలను కలిగి ఉంటుంది: పెద్ద struct నకిలీ చేయడానికి ఖర్చవంతమైనది, మరియు సూచన సెమాంటిక్‌లు (లేదా విలువ) ఆశించిన చోట struct ఉపయోగించడం సూక్ష్మమైన బగ్‌లను కలిగిస్తుంది.

ప్రతి జాతిని ఎప్పుడు ఉపయోగించాలో అర్థం చేసుకోవడం — enum స్థిర స్థిరాంక సెట్‌ల కోసం, struct చిన్న డేటా-సంబంధిత విలువల కోసం (చిన్నగా ఉంచిన), చిత్రత్యాఖ్యత వస్తువుల కోసం class (డిఫాల్ట్) — మరియు విలువ-vs-సూచన సూచనలు C#లో డేటా సరిగ్గా మరియు విలువైనంగా మోడలింగ చేయడానికి ముఖ్యమైన జ్ఞానం.

ఈ ఎంపిక మీరు రకం నిర్వచించిన ప్రతిసారీ కనిపిస్తుంది, మరియు విలువ/సూచన వ్యత్యాసం చాలా C# ప్రవర్తనకు భిన్నమైనది కాబట్టి, enums, structs, మరియు classes యొక్క తేడాలను మరియు తగిన ఉపయోగాన్ని తెలుసుకోవడం C#లోని టైప్ సిస్టమ్‌ను అర్థం చేసుకోవడాన్ని ప్రతిబింబించే నిబంధన, చాలా సంబంధితమైన జ్ఞానం.