C# என்ன கட்டுப்பாட்டு-பாய்வு கட்டமைப்புகளை வழங்குகிறது?

Question

Accepted Answer

C# நிலையான கட்டுப்பாட்டு-பாய்வு கட்டமைப்புகளை வழங்குகிறது — நிபந்தனைகள் (`if`, `switch`), சுழல்கள் (`for`, `foreach`, `while`) மற்றும் கிளைபுரங்கள் (`break`, `continue`, `return`) — கூடுதலாக switch expressions மற்றும் pattern matching போன்ற நவீன மேம்பாடுகள் குறியீட்டை மிகவும் சுருக்கமாக்குகின்றன.

## நிபந்தனைகள்

```csharp
if (score >= 90)
    grade = "A";
else if (score >= 80)
    grade = "B";
else
    grade = "F";

// ternary and null-coalescing
string status = age >= 18 ? "adult" : "minor";
string name = input ?? "default";        // ?? — use default if input is null
name ??= "fallback";                      // ??= assign if null
```

## switch statement மற்றும் நவீன switch expression

```csharp
// traditional switch
switch (day)
{
    case "Sat":
    case "Sun":
        type = "weekend";
        break;                            // break required (no fall-through)
    default:
        type = "weekday";
        break;
}

// switch EXPRESSION (C# 8) — concise, returns a value, with pattern matching
string type = day switch
{
    "Sat" or "Sun" => "weekend",
    _ => "weekday",                        // _ = default
};

// pattern matching in switch
string describe = obj switch
{
    int n when n > 0 => "positive int",
    string s => $"string of length {s.Length}",
    null => "null",
    _ => "other",
};
```

நவீன **switch expression** சுருக்கமாக உள்ளது (ஒரு மதிப்பை வழங்குகிறது, `break` இல்லை), மற்றும் சக்திவாய்ந்த **pattern matching** (வகைகள், நிபந்தனைகள் மற்றும் பலவற்றை பொருத்துதல்) ஆதரிக்கிறது — வாய்வெளியான பாரம்பரிய switch க்கு ஒப்பிடுகையில் பெரிய மேம்பாடு.

## சுழல்கள்

```csharp
for (int i = 0; i < 10; i++) { }

foreach (var item in collection) { }      // iterate any IEnumerable

while (condition) { }
do { } while (condition);                  // runs at least once
```

`foreach` (எந்த `IEnumerable` ஐ மீறி செல்வது) சேகரণங்களுக்கான மக்களவை சுழல் ஆகும்.

## கிளைபுரங்கள்

```csharp
foreach (var item in items)
{
    if (item.Skip) continue;   // next iteration
    if (item.Stop) break;       // exit loop
}
return result;                  // exit method
```

## இது ஏன் முக்கியமானது

கட்டுப்பாட்டு-பாய்வு ஒவ்வொரு நிரலிலும் தர்கத்தை வெளிப்படுத்துவதற்கான அடிப்படை வழிமுறையாகும், எனவே C# கட்டமைப்புகளைப் புரிந்துகொள்வது அடிப்படை அன்றாட அறிவு.

அடிப்படைகள் நிலையான என்றாலும், நவீன C# மேம்பாடுகள் அறிந்துகொள்வது மற்றும் பயன்படுத்துவது மதிப்பு: **switch expression** (C# 8+) பாரம்பரிய switch க்கு ஒப்பிடுகையில் குறிப்பிடத்தக்க மேம்பாடு — சுருக்கமான, மதிப்பு-வழங்கும், வழிதல் பிழைகள் இல்லை (`break` மறந்திருக்கக்கூடாது), மற்றும் **pattern matching** (வகைகள், நிபந்தனைகள், மதிப்புகள் மற்றும் கட்டமைப்பை பொருத்துதல்) ஆதரிக்கிறது, இது சிக்கலான நிபந்தனামய தர்கத்தை இணைக்கப்பட்ட if-else சங்கிலிகளை விட மிகவும் சுத்தமாக்குகிறது.

**null-coalescing operators** (`??`, `??=`) சுத்தமான null கையாளுதலை வழங்குகின்றன, மற்றும் `foreach` சேகரணங்களை மீறி செல்வதற்கான மக்களவை வழி ஆகும்.

இந்த கட்டமைப்புகளை அறிந்துகொள்வது மற்றும் நவீன, மேலும் வெளிப்படுத்தக்கூடிய வடிவங்களை முன்னுரிமை (வாய்வெளியான switch statements க்கு பதிலாக pattern matching உடன் switch expressions, defaults க்கு null-coalescing) சுத்தமான, மக்களவை C# எழுதுவதற்கான அன்றாட அறிவு.

Switch expression மற்றும் pattern matching குறிப்பாக நவீன C# இன் பரিணாமத்தை மிகவும் செயல்பாட்டு, சுருக்கமான குறியீட்டின் பக்கம் பிரதிபலிக்கிறது, இது சிறந்த குறியீட்டை எழுதுவதற்கும் இந்த அம்சங்களை விரிவாகப் பயன்படுத்தும் தற்போதைய C# codebases ஐ படிப்பதற்கும் புரிந்துகொள்வதற்கு முக்கியமானவை ஆகும்.