Methods என்பவை ஒரு class-ல் வரையறுக்கப்பட்ட functions. C# சமृத்தமான parameter features ஐ ஆதரிக்கிறது — optional/named arguments, ref/out/in modifiers, arrays — மற்றும் (ஒரே பெயர் கொண்ட பல methods ஆனால் வெவ்வேறு parameters).
Methods என்பவை ஒரு class-ல் வரையறுக்கப்பட்ட functions. C# சமृத்தமான parameter features ஐ ஆதரிக்கிறது — optional/named arguments, ref/out/in modifiers, arrays — மற்றும் (ஒரே பெயர் கொண்ட பல methods ஆனால் வெவ்வேறு parameters).
paramspublic int Add(int a, int b) => a + b; // expression-bodied (concise)
public string Greet(string name, string greeting = "Hello") // default parameter
{
return $"{greeting}, {name}";
}
Greet("Ann"); // "Hello, Ann"
Greet("Ann", greeting: "Hi"); // named argument
Methods ஒரு return type, name, மற்றும் parameters ஐ குறிப்பிடுகின்றன. Default parameters arguments ஐ விரும்பி வைக்கிறது, மற்றும் named arguments உங்களை பெயரால் pass செய்ய அனுமதிக்கிறது (தெளிவாக, விருப்ப பொருட்களைத் தவிர்க்க முடியும்).
// ref — pass by reference (method can modify the caller's variable)
void Increment(ref int x) { x++; }
int n = 5; Increment(ref n); // n is now 6
// out — for returning multiple values (must be assigned in the method)
bool TryParse(string s, out int result) { result = ...; return true; }
if (int.TryParse("42", out int value)) { } // the common TryX pattern
// in — pass by reference but READ-ONLY (performance for large structs)
void Process(in LargeStruct data) { }
out என்பது TryParse pattern-ல் பரவலாகப் பயன்படுத்தப்படுகிறது (ஒரு success flag மற்றும் முடிவை பாதுகாப்பாக திருப்புதல்); ref அழைப்பாளরின் மாறியை மாற்றுவதை அனுமதிக்கிறது; in பெரிய structs ஐ நகலெடுப்பாமல் திறனுடன் கடந்து செல்கிறது.
// params — variable number of arguments
int Sum(params int[] numbers) => numbers.Sum();
Sum(1, 2, 3, 4); // any number
// OVERLOADING — same name, different parameters
void Print(int x) { }
void Print(string s) { }
void Print(int x, int y) { }
Print(5); // calls the int version — resolved by argument types
Overloading பல methods ஐ ஒரு பெயரைப் பகிர்ந்து கொள்ள அனுமதிக்கிறது, parameter types/count ஆல் வேறுபடுத்தப்படுகிறது — compiler பொருந்தக்கூடிய ஒன்றைத் தேர்ந்தெடுக்கிறது. params மாறுபடும் எண்ணிக்கையிலான arguments ஐ ஏற்றுக்கொள்கிறது.
Methods என்பவை C#-ல் நடத்தையின் கட்டிமண்ணாக இருக்கிறது, மற்றும் அவற்றின் சமृத்த parameter features ஐ புரிந்துகொள்வது நমনीயமான, வெளிப்புற குறிப்பீடு செய்யக்கூடிய குறிப்பு எழுத அத்यாவश்யகமாக இருக்கிறது.
Methods ஐ வரையறுக்கக்கூடிய முறைகள் (concise expression-bodied syntax உட்பட), default மற்றும் named parameters ஐ பயன்படுத்துவது (விரும்பிய arguments மற்றும் படிக்கக்கூடிய அழைப்புகளுக்கு), மற்றும் method overloading ஐ பயன்படுத்துவது (ஒரே பெயர், வெவ்வேறு parameters — நான்கு வகையான பொருட்களைக் கையாளும் உள்ளுணர்வு APIs-க்கு) அறிந்திருப்பது தினசரி ஞ்ஞாணம்.
புரிந்துகொள்வதற்கு parameter modifiers குறிப்பாக महत्त्বपूर्ण இருக்கிறது: out என்பது ubiquitous TryParse pattern-ல் பரவலாகப் பயன்படுத்தப்படுகிறது (int.TryParse(s, out var result) — ஒரு success flag மற்றும் முடிவை பாதுகாப்பாக திருப்புதல் exceptions ஆகாமல், ஒரு பொதுவான, idiomatic C# pattern), ref அழைப்பாளரின் மாறியை மாற்றுவதை செயல்படுத்துகிறது, மற்றும் in performance-க்கு reference மூலம் பெரிய structs ஐ கடந்து செல்கிறது.
இவற்றை புரிந்துகொள்வது — methods, parameter features (optional/named/params), flexible APIs-க்கான overloading, மற்றும் ref/out/in modifiers (குறிப்பாக out-based TryParse idiom) — C# methods எழுதுவதற்கு மற்றும் இந்த features மீது சார்ந்திருக்கும் பல .NET APIs பயன்படுத்துவதற்கும் அடிப்படையாக இருக்கிறது.
Methods மற்றும் அவற்றின் parameters என்பவை அனைத்து C# குறிப்புக்கு மையமாக இருக்கிறது, மற்றும் overloading, optional parameters, மற்றும் TryX pattern போன்ற features என்பவை தொடர்ந்து தோன்றுவதால், அவற்றைக் கரைந்து விடுவது C# development-க்கு কோர், must-know ஞ்ஞாணம்.