enum, struct ਅਤੇ class ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ?

Question

Accepted Answer

ਇਹ C# ਵਿੱਚ ਤਿੰਨ ਵਿਭਿੰਨ ਕਿਸਮਾਂ ਦੀਆਂ types ਹਨ: **enum** (ਸਥਿਰ ਮੁੱਲਾਂ ਦਾ ਨਾਮਿਤ ਸਮੂਹ), **struct** (ਛੋਟੇ ਡੇਟਾ ਲਈ value type), ਅਤੇ **class** (ਵਸਤੂਆਂ ਲਈ reference type)। ਸਹੀ ਚੋਣ ਆਪਣੇ ਡੇਟਾ ਅਤੇ ਵਿਵਹਾਰ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ।

## 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** ਨਾਮਿਤ ਮੁੱਲਾਂ ਦਾ ਇੱਕ ਸਥਿਰ ਸਮੂਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ — states, roles, ਜਾਂ options ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ ਲਈ type-safe ਸਥਿਰਾਂਕ (ਜਾਦੂ ਸੰਖਿਆਵਾਂ/strings ਨੂੰ ਬਦਲਦਾ ਹੈ)। ਇਹ ਇੱਕ integer ਦੁਆਰਾ ਬੈਕਡ 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 ਨਹੀਂ। **ਛੋਟੇ, ਬਦਲਾਵਰਹਿਤ, ਡੇਟਾ-ਸਮਾਨ** ਮੁੱਲਾਂ (coordinates, money, ਇੱਕ date) ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਜਿੱਥੇ value semantics ਅਤੇ heap allocation ਕੀ ਪ੍ਰਦੂਸ਼ਣ ਮਦਦ ਕਰਦੀ ਹੈ।

## class — ਵਸਤੂਆਂ ਲਈ 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 ਦੁਆਰਾ ਕਾਪੀ ਕੀਤਾ (shared), inheritance ਅਤੇ ਸਮਿਧ ਵਿਵਹਾਰ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਬਹੁਮਤ ਵਸਤੂਆਂ ਲਈ ਡਿਫ਼ਾਲਟ ਚੋਣ ਜਿਨ੍ਹਾਂ ਕੋਲ identity, ਵਿਵਹਾਰ, ਅਤੇ 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# ਡਿਜ਼ਾਈਨ ਫ਼ੈਸਲਾ ਹੈ ਜੋ ਸ਼ੁੱਧਤਾ, semantics, ਅਤੇ ਪ੍ਰਦੂਸ਼ਣ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਅੰਤਰਾਂ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। **Enums** type-safe ਨਾਮਿਤ ਸਥਿਰਾਂਕ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ (states, roles, options ਲਈ), error-prone ਜਾਦੂ ਸੰਖਿਆਵਾਂ ਜਾਂ strings ਨਾਲੋਂ ਬਹੁਤ ਚੰਗੇ — ਇੱਕ ਆਮ, ਮੁੱਲਵਾਨ modeling ਸਾਧਨ।

**struct vs class** ਅੰਤਰ ਵਿਸ਼ੇਸ਼ ਤੌਰ ਉੱਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਇਹ **value vs reference semantics** ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ: structs value types ਹਨ (value ਦੁਆਰਾ ਕਾਪੀ ਕੀਤੇ, inline ਸਟੋਰ ਕੀਤੇ, heap allocation ਨਹੀਂ) ਛੋਟੇ immutable ਡੇਟਾ ਮੁੱਲਾਂ ਲਈ ਢੁੱਕ ਰਹੇ ਹਨ ਜਿੱਥੇ value semantics ਅਤੇ ਘਟੀ allocation ਮਦਦ ਕਰਦੀ ਹੈ, ਜਦਕਿ classes reference types ਹਨ (reference ਦੁਆਰਾ shared, heap-allocated, inheritance ਅਤੇ ਸਮਿਧ ਵਿਵਹਾਰ ਦਾ ਸਮਰਥਨ) — ਬਹੁਮਤ ਵਸਤੂਆਂ ਲਈ ਡਿਫ਼ਾਲਟ ਜਿਨ੍ਹਾਂ ਕੋਲ identity ਅਤੇ ਵਿਵਹਾਰ ਹੋ।

ਗਲਤ ਚੋਣ ਦੇ ਅਸਲੀ ਨਤੀਜੇ ਹਨ: ਇੱਕ ਵੱਡਾ struct ਕਾਪੀ ਕਰਨ ਲਈ ਮਹਿੰਗਾ ਹੈ, ਅਤੇ ਉਥੇ struct ਦਾ ਇਸਤੇਮਾਲ ਕਰਨਾ ਜਿੱਥੇ reference semantics ਲੋੜੀਦੇ ਹਨ (ਜਾਂ ਉਲਟ) subtle bugs ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ।

ਸਮਝਣਾ ਕਿ ਹਰ ਇੱਕ ਦਾ ਕਦੋਂ ਇਸਤੇਮਾਲ ਕਰੀਏ — enum ਲਈ fixed constant sets, struct ਲਈ ਛੋਟੇ ਡੇਟਾ-ਸਮਾਨ ਮੁੱਲ (ਛੋਟੇ ਰੱਖੇ), class ਲਈ ਬਹੁਮਤ ਵਸਤੂਆਂ (ਡਿਫ਼ਾਲਟ) — ਅਤੇ value-vs-reference ਪ੍ਰਭਾਵ C# ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸਹੀ ਅਤੇ efficiently ਮਾਡਲ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਗਿਆਨ ਹੈ।

ਕਿਉਂਕਿ ਇਹ ਚੋਣ ਹਰ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ type ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ value/reference ਅੰਤਰ C# ਦੇ ਸਾਥ ਇਹ ਸਭ ਕੁਝ ਨੂੰ ਅੰਡਰਲਾਈ ਕਰਦਾ ਹੈ, enums, structs, ਅਤੇ classes ਦੇ ਅੰਤਰਾਂ ਅਤੇ ਉਚਿਤ ਇਸਤੇਮਾਲ ਨੂੰ ਜਾਣਨਾ C# ਦੀ type system ਦਾ ਸਮਝ ਦਰਸਾਦੇ ਹੋਏ ਬੁਨਿਆਦੀ, ਅਕਸਰ-ਲਾਗੂ ਗਿਆਨ ਹੈ ਅਤੇ ਇੱਕ ਆਮ interview ਵਿਸ਼ਾ।