તમે ચલ્ફો (variables) કેવી રીતે વર્ણવો અને `var` નો ઉપયોગ કેવો કરો?

Question

Accepted Answer

C# સ્ટેટિક્‍ટી ટાઇપ્ડ છે — ચલ્ફોમાં ટાઇપ કમ્પાઇલ સમયે જાણીતો હોય છે. તમે સ્પષ્ટ ટાઇપ સાથે ચલ્ફો વર્ણવી શકો અથવા **`var`** નો ઉપયોગ કરી શકો ટાઇપ ઇનફરન્સ માટે (કમ્પાઇલર મૂલ્ય પરથી ટાઇપ અનુમાન કરે છે), પણ કોઇ પણ રીતે ટાઇપ નિર્ધારિત છે. ## ચલ્ફો વર્ણવવા ```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` ઇનિશિયલાઇઝર પરથી ટાઇપ અનુમાન કરે છે — `var age = 30` બરાબર `int age = 30` છે. મહત્‍વપૂર્ણ રીતે, **`var` હજુ સ્ટેટિક્‍ટી ટાઇપ્ડ છે**: ટાઇપ કમ્પાઇલ સમયે નિર્ધારિત છે (તમે બાદમાં `age` ને સ્ટ્રિંગ અસાઇન કરી શકતા નથી); તે માત્ર અનુમાન છે, ડાયનામિક નથી. ## var ને ઇનિશિયલાઇઝર જોઇએ અને ટાઇપ નિર્ધારિત રાખે છે ```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 ``` ## var નો ઉપયોગ ક્યારે કરવો (સ્ટાઇલ) ```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 ``` `var` નો ઉપયોગ કરો જ્યારે ટાઇપ જમણી બાજુ પરથી સ્પષ્ટ હોય (વધુ સંક્ષિપ્ત બનાવે છે, ખાસ લાંબા જેનેરિક ટાઇપ્સ સાથે); સ્પષ્ટ ટાઇપ્સ નો ઉપયોગ કરો જ્યારે તે સ્પષ્ટતા આપે. ## કોન્સ્ટંટ્સ અને અન્ય વર્ણવવા ```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 ``` ## સામાન્ય બિલ્ટ-ઇન ટાઇપ્સ ```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 ``` ## શું મહત્‍વપૂર્ણ છે ચલ્ફો વર્ણવવા અને `var` નું સમજ C# ની પ્રતિદિના અને મૌલિક જ્ઞાન છે. મુખ્ય કલ્પનાત્મક બિંદુ એ છે કે **`var` ટાઇપ ઇનફરન્સ છે, ડાયનામિક ટાઇપિંગ નથી** — એક સામાન્ય ગેરસમજણા. `var` સાથે, કમ્પાઇલર ઇનિશિયલાઇઝર પરથી ટાઇપ અનુમાન કરે છે, પણ ટાઇપ હજુ કમ્પાઇલ સમયે નિર્ધારિત છે (તમને સ્ટેટિક ટાઇપિંગ ના બધા ફાયદા મળે છે — ટાઇપ ચેકિંગ, ઇન્ટેલિસેન્સ, પર્ફોર્મન્સ), માત્ર ટાઇપ નામ સ્પષ્ટ રીતે લખ્યુ છે નહીં. આ `var` ને વાચનીયતા માટે સુવિધા બનાવે છે (ખાસ કરીને વર્બોસ જેનેરિક ટાઇપ્સ સાથે જેમ કે `Dictionary>`) તેના બદલે ટાઇપ સિસ્ટમમાં શૈથિલ્ય લાવવું. જાણવું એ છે કે `var` નો ઉપયોગ ક્યારે કરવો (જ્યારે ટાઇપ જમણી બાજુ પરથી સ્પષ્ટ હોય, સંક્ષિપ્ત બનાવે છે) સામે સ્પષ્ટ ટાઇપ્સ (જ્યારે તે સ્પષ્ટતા આપે), બિલ્ટ-ઇન ટાઇપ્સ સાથે (ખાસ **`decimal` નાણાં માટે** — ચોક્કસ દશાંશ અંકગણિત, `double` ની તરફથી અલગ), કોન્સ્ટંટ્સ (`const`, `readonly`), C# લખવાની રોજીંદી જ્ઞાન છે. જાણવું એ છે કે C# સંપૂર્ણ રીતે સ્ટેટિક્‍ટી ટાઇપ્ડ છે (ભલે તમે ટાઇપ લખો અથવા `var` નો ઉપયોગ કરો), અને ચલ્ફો વર્ણવવાની આસપાસ ની રીતો, સ્વચ્છ, યોગ્ય C# કોડ વાંચવા અને લખવા માટે પાયાનું છે, અને `var`-નથી-ડાયનામિક પોઇન્ટ વારંવાર સ્પષ્ટતા છે જે ભાષાની યોગ્ય સમજણ પ્રતિબિંબિત કરે છે.