Yaya kake bayyana variables kuma sannan kake amfani da var?

Question

Accepted Answer

C# yana da nau'awa a tsaye — variables suna da nau'i da aka sani a lokacin girka. Kana iya bayyana variable tare da nau'i sarari ko kuma amfani da **`var`** don zainawa na nau'i (compiler din ya zainawa nau'in daga kimar), amma ko ta waje nau'i an gyara shi. ## Bayyanar variables ```csharp int count = 42; // explicit type string name = "Ann"; double price = 9.99; bool active = true; var age = 30; // inferred as int (var = let the compiler figure it out) var message = "Hello"; // inferred as string var items = new List(); // inferred as List ``` `var` yana zainawa nau'in daga initializer — `var age = 30` daidai yake da `int age = 30`. A mahimmanci, **`var` har yanzu ana sanye a tsaye**: nau'i an gyara shi a lokacin girka (ba za ka iya bayyanar string ga `age` daga gida ba); shine kawai zainawa, ba dynamic ba. ## var yana buƙa initializer kuma yana kiyaye nau'i da ya aka gyara ```csharp var x = 5; x = "hi"; // ❌ compile error — x is an int, can't become a string var y; // ❌ error — var needs an initializer to infer from ``` ## Lokaci na amfani da var (style) ```csharp var user = new UserService(); // ✅ type is obvious from the right side — var is clean var count = users.Count; int total = CalculateComplexValue(); // explicit when the type isn't obvious aids readability ``` Amfani da `var` lokacin da nau'i ya kasance bayyane daga gida na dama (yana rage karanci, musamman da nau'i mai tsayi na generic); amfani da nau'i sarari lokacin da ya taya halin bayyane. ## Constants da sauran bayyana ```csharp const double Pi = 3.14159; // compile-time constant (can't change) readonly int id; // set once (in constructor), then immutable int a = 1, b = 2; // multiple of the same type nint nativeInt; // platform-sized integer ``` ## Nau'awa na jiya na inai ```text int, long, short, byte integers float, double, decimal floating point (decimal for money — exact) bool, char, string boolean, character, text object the base of all types ``` ## Me ya sa ya matuwa Ganindan bayyana variable kuma `var` shine ilimi na gaida na yau-yau C#. Mahimmancin tunani shine cewa **`var` shine zainawa na nau'i, ba dynamic typing ba** — wannan shine gaskiyar da aka saba yi. Tare da `var`, compiler yana zainawa nau'in daga initializer, amma nau'i har yanzu an gyara shi a lokacin girka (kana samun dukan fa'ida na sanye a tsaye — dumama nau'i, IntelliSense, karfi), kawai sai ba ka rubuce nau'in sunan bayyane ba. Wannan yana sa `var` sauki don karanta (musamman da nau'i mai tsayi na generic kamar `Dictionary>`) maimakon rage tsarin nau'i. Sanin lokaci na amfani da `var` (lokacin da nau'i ya kasance bayyane daga gida na dama, yana rage redundancy) in tare da nau'i sarari (lokacin da ya taya halin bayyane), tare da nau'i na jiya na inai (musamman **`decimal` don kusu** — jujjuyawar adadi mai daidaito, ba kamar `double` ba), constants (`const`, `readonly`), shine ilimi na yau-yau don rubuce C#. Ganindan cewa C# ana sanye a tsaye a duk waje (ko kana rubuce nau'i ko amfani da `var`), kuma idioms game da bayyana variable, shine tsari na ginawa don karanta kuma rubuce C# da tsafi, daidai, kuma mahimmancin `var`-ba-dynamic na baki ita ce gaskiyar sau-sau da ta nuna jujjuya batabatawal na harshe.