Methods ni functions zilizofafanuliwa katika class. C# inaunga mkono vipengele tajiri vya parameters — optional/named arguments, modifiers za ref/out/in, arrays — na (methods nyingi zenye jina moja lakini parameters tofauti).
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 hubainisha return type, jina, na parameters. Default parameters hufanya arguments ziwe za hiari, na named arguments hukuruhusu kupitisha kwa jina (wazi zaidi, zinaweza kuruka optionals).
// 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 hutumika sana katika TryParse pattern (kurudisha flag ya mafanikio pamoja na matokeo kwa usalama); ref huruhusu kubadilisha variable ya caller; in hupitisha structs kubwa kwa ufanisi bila kunakili.
// 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 huruhusu methods nyingi kushiriki jina, zikitofautishwa na aina/idadi ya parameters — compiler huchagua inayolingana. params hukubali idadi inayobadilika ya arguments.
Methods ni vipengele vya ujenzi vya tabia katika C#, na kuelewa vipengele vyake tajiri vya parameters ni muhimu kwa kuandika msimbo unaonyumbulika na wenye msemo.
Kujua jinsi ya kufafanua methods (ikiwa ni pamoja na syntax fupi ya expression-bodied), kutumia default na named parameters (kwa arguments za hiari na calls zinazosomeka), na kutumia method overloading (jina moja, parameters tofauti — kwa APIs za kintuitive zinazoshughulikia aina tofauti za arguments) ni maarifa ya kila siku.
Parameter modifiers ni muhimu hasa kuzielewa: out hutumika sana katika TryParse pattern iliyoenea (int.TryParse(s, out var result) — kurudisha kwa usalama flag ya mafanikio na matokeo bila exceptions, pattern ya kawaida, ya idiomatic ya C#), ref huwezesha kubadilisha variable ya caller, na in hupitisha structs kubwa kwa reference kwa performance.
Kuelewa haya — methods, vipengele vya parameters (optional/named/params), overloading kwa APIs zinazonyumbulika, na modifiers za ref/out/in (hasa idiom ya TryParse inayotegemea out) — ni msingi kwa kuandika methods za C# na kutumia APIs nyingi za .NET zinazotegemea vipengele hivi.
Kwa kuwa methods na parameters zake ni za kati kwa msimbo wote wa C#, na kwa kuwa vipengele kama overloading, optional parameters, na pattern ya TryX zinaonekana mara kwa mara, kumiliki vyao ni maarifa ya msingi, ya lazima kwa maendeleo bora ya C#.