ਮੁੱਲ ਅਤੇ ਹਵਾਲਾ ਕਿਸਮਾਂ ਵਿਚਕਾਰ ਕੀ ਅੰਤਰ ਹੈ?

Question

Accepted Answer

C# ਕਿਸਮਾਂ ਦੋ ਬੁਨਿਆਦੀ ਸ਼੍ਰੇਣੀਆਂ ਵਿੱਚ ਆਉਂਦੀਆਂ ਹਨ: **ਮੁੱਲ ਕਿਸਮਾਂ** (ਡੇਟਾ ਸਿੱਧੇ ਸਟੋਰ ਕਰਦੀਆਂ ਹਨ) ਅਤੇ **ਹਵਾਲਾ ਕਿਸਮਾਂ** (heap ਉੱਤੇ ਡੇਟਾ ਦਾ ਸੰਦਰਭ/ਪੁਆਇੰਟਰ ਸਟੋਰ ਕਰਦੀਆਂ ਹਨ)। ਇਹ ਇਸ ਗੱਲ ਵਿੱਚ ਭਿੰਨ ਹਨ ਕਿ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਕਾਪੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ — ਇਹ ਪੂਰੀ ਭਾਸ਼ਾ ਵਿੱਚ ਵਿਵਹਾਰ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਵਾਲਾ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਅੰਤਰ ਹੈ।

## ਦੋਵੇਂ ਸ਼੍ਰੇਣੀਆਂ

```text
Value types     → struct, int, double, bool, char, enum, DateTime, decimal
                  Stored INLINE (stack for locals); copied BY VALUE.
Reference types → class, string, array, object, interface, delegate
                  Variable holds a REFERENCE to data on the heap; copied BY REFERENCE.
```

## ਮੁੱਖ ਅੰਤਰ: ਕਾਪੀ ਅਰਥ ਸ਼ਾਸਤਰ

```csharp
// VALUE type — assignment COPIES the value (independent)
int a = 5;
int b = a;      // b is a COPY
b = 10;         // a is still 5

struct Point { public int X; }
Point p1 = new() { X = 1 };
Point p2 = p1;  // COPIES the whole struct
p2.X = 99;      // p1.X is still 1

// REFERENCE type — assignment copies the REFERENCE (both point to the SAME object)
class Box { public int Value; }
Box box1 = new() { Value = 1 };
Box box2 = box1;   // both reference the SAME Box
box2.Value = 99;   // box1.Value is now 99 too!
```

ਇੱਕ ਮੁੱਲ ਕਿਸਮ ਨੂੰ ਨਿਯੁਕਤ ਕਰਨਾ ਡੇਟਾ ਨੂੰ ਕਾਪੀ ਕਰਦਾ ਹੈ (ਸੁਤੰਤਰ); ਇੱਕ ਹਵਾਲਾ ਕਿਸਮ ਨੂੰ ਨਿਯੁਕਤ ਕਰਨਾ ਸੰਦਰਭ ਨੂੰ ਕਾਪੀ ਕਰਦਾ ਹੈ (ਦੋਵੇਂ ਨਾਮ ਇਕੋ ਆਬਜੈਕਟ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ, ਇਸ ਲਈ ਇੱਕ ਦੁਆਰਾ ਪਰਿਵਰਤਨ ਦੂਜੇ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ)।

## ਤੁਲਨਾ ਅਤੇ ਢੰਗਾਂ ਕੋ ਪਾਸ ਕਰਨਾ

```csharp
// == compares VALUES for value types, REFERENCES (identity) for reference types
string s1 = "hi"; // (string is special — == compares content)
Box b1 = new(), b2 = new();
b1 == b2;   // false — different objects (reference equality by default)

// methods get a COPY of value types, the reference (by value) for reference types
void Modify(Box b) { b.Value = 100; }   // affects the caller's object
void Modify(int x) { x = 100; }           // does NOT affect the caller's int
```

## null

```text
Reference types can be null (no object). Value types CANNOT be null
(unless made nullable: int? — a Nullable<int>).
```

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਮੁੱਲ-ਬਨਾਮ-ਹਵਾਲਾ ਵਿਸ਼ੋਤਰ C# ਵਿੱਚ ਸਭ ਤੋਂ ਬੁਨਿਆਦੀ ਸੰਕਲਪਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਅਤੇ ਇਹ ਵਿਵਹਾਰ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਰੇਂਜ ਅਤੇ ਬਗਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰਦਾ ਹੈ — ਇਸਨੂੰ ਜ਼ਰੂਰੀ ਗਿਆਨ ਬਣਾਉਂਦਾ ਹੈ।
\\ury ਕਿ **ਮੁੱਲ ਕਿਸਮਾਂ** (structs, int/double ਵਰਗੇ ਪ੍ਰਾਇਮਿਟਿਵ, enums) ਮੁੱਲ ਦੁਆਰਾ ਕਾਪੀ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ (ਸੁਤੰਤਰ ਕਾਪੀਆਂ) ਜਦਕਿ **ਹਵਾਲਾ ਕਿਸਮਾਂ** (classes, arrays, strings) ਸੰਦਰਭ ਦੁਆਰਾ ਕਾਪੀ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ (ਦੋਵੇਂ ਨਾਮ ਇਕੋ ਆਬਜੈਕਟ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ) ਸਮਝਣਾ ਲਾਜ਼ਮੀ ਹੈ ਕਿ ਡੇਟਾ ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ: ਮੁੱਲ-ਕਿਸਮ ਦੀ ਕਾਪੀ ਨੂੰ ਸੋਧਣਾ ਅਸਲ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਦਾ, ਪਰ ਇੱਕ ਸਾਂਝੇ ਹਵਾਲਾ-ਕਿਸਮ ਆਬਜੈਕਟ ਨੂੰ ਪਰਿਵਰਤਨ ਕਰਨਾ ਇਸ ਦੇ ਸਾਰੇ ਸੰਦਰਭਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ (ਆਸਚਰਯਜਨਕ ਬਗਾਂ ਦਾ ਇੱਕ ਆਮ ਸ੍ਰੋਤ)।

ਇਹ ਵਿਸ਼ੋਤਰ **ਸਮਤਾ** ਨੂੰ ਵੀ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ (`==` ਮੁੱਲ ਕਿਸਮਾਂ ਲਈ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਪਰ ਮੂਲ ਰੂਪ ਨਾਲ ਹਵਾਲਾ ਕਿਸਮਾਂ ਲਈ ਸੰਦਰਭ ਪਛਾਣ), **ਢੰਗ ਦਲੀਲਾਂ** (ਮੁੱਲ ਕਿਸਮਾਂ ਕਾਪੀਆਂ ਵਜੋਂ ਲੰਘਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਹਵਾਲਾ ਕਿਸਮਾਂ ਦੇ ਸੰਦਰਭ ਮੁੱਲ ਦੁਆਰਾ ਲੰਘਾਏ ਜਾਂਦੇ ਹਨ — ਇਸ ਲਈ ਢੰਗ ਇੱਕ ਲੰਘਾਏ ਆਬਜੈਕਟ ਨੂੰ ਪਰਿਵਰਤਨ ਕਰ ਸਕਦੇ ਹਨ ਪਰ ਇੱਕ ਲੰਘਾਈ int ਨੂੰ ਨਹੀਂ), ਅਤੇ **nullability** (ਸਿਰਫ਼ ਹਵਾਲਾ ਕਿਸਮਾਂ null ਹੋ ਸਕਦੀਆਂ ਹਨ, ਜਦ ਤੱਕ ਇੱਕ ਮੁੱਲ ਕਿਸਮ `?` ਨਾਲ nullable ਨਹੀਂ ਬਣਾਈ ਜਾਂਦੀ)।

ਇਹ ਸਮਝਣਾ ਕਿ ਕਿਹੜੀਆਂ ਕਿਸਮਾਂ ਮੁੱਲ ਬਨਾਮ ਹਵਾਲਾ ਹਨ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ ਕਾਪੀ, ਤੁਲਨਾ, ਅਤੇ ਪਰਿਵਰਤਨ ਅਰਥ ਸ਼ਾਸਤਰ ਸਹੀ C# ਲਿਖਣ ਲਈ ਅਤੇ ਭਾਸ਼ਾ ਦੀਆਂ ਸਭ ਤੋਂ ਆਮ ਸੰਕਲਪੀ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਲਈ ਮੂਲ ਹੈ — ਇਹ ਇਸ ਗੱਲ ਨੂੰ ਅੰਡਿਲਆ ਹੋਇਆ ਹੈ ਕਿ ਡੇਟਾ ਪ੍ਰੋਗ੍ਰਾਮ ਵਿੱਚ ਕਿਵੇਂ ਵਹਿਦਾ ਹੈ ਅਤੇ ਇਹ ਸਾਖਲਤ ਵਾਲ ਸਵਾਲ ਵਿਸ਼ੇ ਹੈ ਕਿਉਂਕਿ ਇਹ ਵਿਚਕਾਰ ਖੁਲ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਇੱਕ ਡੈਵਲਪਰ ਸੱਚਮੁੱਚ C# ਦੀ ਕਿਸਮ ਪ੍ਰਣਾਲੀ ਨੂੰ ਸਮਝਦਾ ਹੈ।