C# స్టాటిక్గా టైప్ చేయబడింది — వేరియబుల్లు కంపైల్ సమయంలో తెలిసిన రకాన్ని కలిగి ఉంటాయి. మీరు వేరియబుల్ను స్పష్టమైన రకంతో ప్రకటించవచ్చు లేదా టైప్ ఇన్ఫరెన్స్కు **var**ను ఉపయోగించవచ్చు (కంపైలర్ విలువ నుండి రకాన్ని ఊహించుకుంటుంది), కానీ ఎలాగైనా రకం నిర్ణీతమైనది.
count = ;
name = ;
price = ;
active = ;
age = ;
message = ;
items = List<>();
var ఇనిషియలైజర్ నుండి రకాన్ని ఊహించుకుంటుంది — var age = 30 ఖచ్చితంగా int age = 30కు సమానం. ముఖ్యమైనది, var ఇప్పటికీ స్టాటిక్గా టైప్ చేయబడినది: రకం కంపైల్ సమయంలో నిర్ణీతమైనది (ageకు తర్వాత string నిర్దేశించలేరు); ఇది కేవలం ఊహించుకోబడినది, డైనమిక్ కాదు.
var కు ఇనిషియలైజర్ అవసరం మరియు రకం నిర్ణీతంగా ఉంటుంది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ను ఎప్పుడు ఉపయోగించాలి (శైలి)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ను ఉపయోగించండి (పునరుచ్చరణను తగ్గిస్తుంది, ప్రత్యేకించి సుదీర్ఘ generic రకాలతో); స్పష్టత సాధించాలంటే స్పష్టమైన రకాలను ఉపయోగించండి.
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
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తో, కంపైలర్ ఇనిషియలైజర్ నుండి రకాన్ని ఊహించుకుంటుంది, కానీ రకం ఇప్పటికీ కంపైల్ సమయంలో నిర్ణీతమైనది (మీరు స్టాటిక్ టైపింగ్ యొక్క అన్ని ప్రయోజనాలను పొందుతారు — టైప్ చెకింగ్, IntelliSense, పనితీరు), కేవలం రకం పేరును స్పష్టంగా వ్రాయడం లేకుండా.
ఇది varను సౌకర్యం కోసం చదవగలిగిన సంస్కరణ చేస్తుంది (ప్రత్యేకించి సవరణమైన generic రకాలతో Dictionary<string, List<int>>లాంటివి), రకం వ్యవస్థను సడలించడం కాదు.
varను ఎప్పుడు ఉపయోగించాలో తెలుసుకోవడం (రకం సరిపక్కి నుండి స్పష్టంగా ఉన్నప్పుడు, పునరుచ్చరణను తగ్గిస్తుంది) వర్సెస్ స్పష్టమైన రకాలు (ఇది స్పష్టత సాధించినప్పుడు), అంతర్నిర్మిత రకాలతో (ముఖ్యంగా decimal డబ్బికోసం — ఖచ్చితమైన దశాంశ అంకగణితం, doubleకు భిన్నంగా), స్థిరాంకాలు (const, readonly), C#ను వ్రాయడం కోసం రోజువారీ జ్ఞానం.
C# స్టాటిక్గా టైప్ చేయబడిందని అర్థం చేసుకోవడం (మీరు రకాన్ని వ్రాయండో లేదా varను ఉపయోగించండో), మరియు వేరియబుల్ ప్రకటన చుట్టూ ఉన్న పదబంధాలు, స青, సరైన C# కోడ్ను చదవడానికి మరియు వ్రాయడానికి ఆధారమైనవి, మరియు var-is-not-dynamic బిందువు భాషపై సరైన అవగాహనను ప్రతిఫలిస్తుంది తరచుగా స్పష్టీకరణ.