ક્લાસ, કન્સ્ટ્રક્ટર અને પ્રોપર્ટીઝ કેવી રીતે કામ કરે છે?

Question

Accepted Answer

**ક્લાસ** એ C#ના ઑબ્જેક્ટ-ઓરિએન્ટેડ મૉડલના આધાર છે — ઑબ્જેક્ટ્સ માટે બ્લુપ્રિન્ટ્સ, **કન્સ્ટ્રક્ટર્સ** (ઑબ્જેક્ટ્સને આરંભ કરે છે) અને **પ્રોપર્ટીઝ** (ડેટાへ નિયંત્રિત ઍક્સેસ) સાથે. C#ની પ્રોપર્ટી સિન્ટેક્સ એક વિશિષ્ટ, મોહક વૈશિષ્ટ્ય છે.

## કન્સ્ટ્રક્ટર અને પ્રોપર્ટીઝ સાથે એક ક્લાસ

```csharp
public class Person
{
    // auto-implemented PROPERTY — encapsulated access with get/set
    public string Name { get; set; }
    public int Age { get; private set; }      // settable only within the class
    public string Email { get; init; }          // set only during initialization (C# 9)

// CONSTRUCTOR
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

public string Greet() => $"Hi, I'm {Name}";   // a method
}

var person = new Person("Ann", 30);    // create an instance
person.Name = "Bob";                     // set a property
Console.WriteLine(person.Greet());
```

## પ્રોપર્ટીઝ — encapsulation ને મોહક બનાવે છે

```csharp
// auto-property (the common case) — compiler generates the backing field
public string Name { get; set; }

// property with custom logic
private decimal _balance;
public decimal Balance
{
    get => _balance;
    set => _balance = value >= 0 ? value : throw new ArgumentException();   // validation
}

// expression-bodied / computed property
public string FullName => $"{First} {Last}";   // read-only, computed
```

**પ્રોપર્ટીઝ** ક્ષેત્રો જેવી દેખાય છે પરંતુ તેઓ વાસ્તવમાં પદ્ધતિઓ છે (`get`/`set`) — encapsulation પ્રદાન કરે છે (નિયંત્રિત ઍક્સેસ, માન્યતા, કમ્પ્યુટેડ મૂલ્યો) સ્વચ્છ સિન્ટેક્સ સાથે. ઑટો-પ્રોપર્ટીઝ (`{ get; set; }`) સામાન્ય કિસ્સાને કોઈ બોઇલરપ્લેટ વિના હેન્ડલ કરે છે.

## ઑબ્જેક્ટ ઇનિશિયલાઇઝર્સ અને આધુનિક વૈશિષ્ટ્યો

```csharp
var p = new Person("Ann", 30) { Email = "a@x.com" };   // object initializer

// primary constructor (C# 12) — concise constructor parameters
public class Point(int x, int y)
{
    public int X { get; } = x;
}
```

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

ક્લાસ, કન્સ્ટ્રક્ટર્સ અને પ્રોપર્ટીઝ એ ઑબ્જેક્ટ-ઓરિએન્ટેડ C#ના આધાર છે — લગભગ તમામ C# કોડ ક્લાસમાં સંગઠિત છે, તેથી તેમને સમજવું કોઈપણ C# ડેવલપમેન્ટ માટે આવશ્યક છે.

કન્સ્ટ્રક્ટર્સ સાથે ક્લાસ્સ વ્યાખ્યાયિત કરવી (ઑબ્જેક્ટ્સને આરંભ કરવું) અને પદ્ધતિઓ કેવી રીતે વ્યાખ્યાયિત કરવી તે જાણવું મૌલિક છે, પરંતુ C#ની **પ્રોપર્ટીઝ** ખાસ કરીને મહત્વપૂર્ણ અને વિશિષ્ટ વૈશિષ્ટ્ય છે જે સારીથી સમજવા યોગ્ય છે.

પ્રોપર્ટીઝ **encapsulation** ને મોહક રીતે પ્રદાન કરે છે — તેઓ ક્ષેત્રો જેવી દેખાય છે પરંતુ તેઓ વાસ્તવમાં `get`/`set` પદ્ધતિઓ છે, નિયંત્રિત ઍક્સેસ, માન્યતા, કમ્પ્યુટેડ મૂલ્યો અને ઍક્સેસ મોડિફાયર્સ (`private set` અથવા `init`-માત્ર) ને મંજૂરી આપે છે જ્યારે સ્વચ્છ સિન્ટેક્સ રાખે છે. **ઑટો-પ્રોપર્ટીઝ** (`{ get; set; }`) સામાન્ય કિસ્સાને શૂન્ય બોઇલરપ્લેટ સાથે હેન્ડલ કરે છે, encapsulation ને સહજ બનાવે છે (અન્ય ભાષાઓથી વિપરીત જ્યાં તમે સ્પષ્ટ getter/setter પદ્ધતિઓ લખો છો).

પ્રોપર્ટીઝ (ઑટો-પ્રોપર્ટીઝ, કસ્ટમ તર્ક, કમ્પ્યુટેડ/રીડ-ઓનલી, `init`-માત્ર અપરિવર્તનીયતા માટે), કન્સ્ટ્રક્ટર્સ, ઑબ્જેક્ટ ઇનિશિયલાઇઝર્સ અને આધુનિક સુવિધાઓ (પ્રાથમિક કન્સ્ટ્રક્ટર્સ) ને સમજવું C# ક્લાસ્સ લખવા માટે મૂલ, રોજિંદા જ્ઞાન છે.

ક્લાસ્સ એ તમે C# એપ્લીકેશન્સમાં ડેટા અને વર્તણૂક મૉડેલ કેવી રીતે છે, અને પ્રોપર્ટીઝ એ C# નો મૂર્તિમત, મોહક રીતે encapsulation હેન્ડલ કરવાનો રીતો છે (એક વિશિષ્ટ ભાષાની વૈશિષ્ટ્ય સતત વપરાતી છે), આ માસ્ટર કરવું — ખાસ કરીને પ્રોપર્ટી સિસ્ટમ — અસરકારક ઑબ્જેક્ટ-ઓરિએન્ટેડ C# ડેવલપમેન્ટ માટે આધારભૂત, જરૂરી જ્ઞાન છે.