મેથડ્સ એ ક્લાસમાં વ્યાખ્યાયિત ફંક્શનો છે. C# સમૃદ્ધ પેરામીટર સુવિધાઓને સમર્થન આપે છે — વૈકલ્પિક/નામિત દલીલો, ref/out/in મોડિફાયર્સ, params એરે — અને (એક જ નામ વાળી બહુવિધ મેથડ્સ પરંતુ વિવિધ પેરામીટર્સ).
public 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
મેથડ્સ રિટર્ન ટાઇપ, નામ અને પેરામીટર્સ નિર્દિષ્ટ કરે છે. ડિફોલ્ટ પેરામીટર્સ દલીલોને વૈકલ્પિક બનાવે છે, અને નામિત દલીલો તમને નામ દ્વારા પાસ કરવા દે છે (સ્પષ્ટ, વૈકલ્પિકો છોડી શકે છે).
// 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 પેટર્નમાં ઉપયોગમાં લેવાય છે (સફળતા ફ્લેગ અને પરિણામ સુરક્ષિત રીતે રીટર્ન કરવા); ref કૉલરના ચલમાં ફેરફાર કરવાની મંજૂરી આપે છે; in નકલ કર્યા વિના મોટી સ્ટ્રક્ટ્સને કાર્યક્ષમતાથી પાસ કરે છે.
// 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
ઓવરલોડીંગ બહુવિધ મેથડ્સને એક નામ શેર કરવા દે છે, પેરામીટર ટાઇપ્સ/સંખ્યા દ્વારા અલગ કરાયેલ — કમ્પાઇલર મેળતી એક પસંદ કરે છે. params દલીલોની ચલ સંખ્યા સ્વીકાર કરે છે.
મેથડ્સ C#માં વર્તનના નિર્માણ બ્લોક્સ છે, અને તેમની સમૃદ્ધ પેરામીટર સુવિધાઓને સમજવું લવચીક, સમર્થક કોડ લખવા માટે મહત્વપૂર્ણ છે.
મેથડ્સ કેવી રીતે વ્યાખ્યાયિત કરવી તે જાણવું (સંક્ષિપ્ત expression-bodied સિંટેક્સ સહિત), ડિફોલ્ટ અને નામિત પેરામીટર્સ (વૈકલ્પિક દલીલો અને વાંચી શકાય એવા કૉલ્સ માટે) ઉપયોગ કરવું, અને મેથડ ઓવરલોડીંગ (એક જ નામ, વિવિધ પેરામીટર્સ — સહજ API માટે જે વિવિધ દલીલ ટાઇપ્સ સંભાળે) લાગુ કરવું તે દૈનિક જ્ઞાન છે.
પેરામીટર મોડિફાયર્સ સમજવા માટે ખાસ કરીને મહત્વપૂર્ણ છે: out વ્યાપકપણે સર્વવ્યાપી TryParse પેટર્ન (int.TryParse(s, out var result) — સફળતા ફ્લેગ અને પરિણામ સુરક્ષિત રીતે પરત કરવું અપવાદો વિના, એક સામાન્ય, રૂઢિચુસ્ત C# પેટર્ન)માં ઉપયોગમાં લેવાય છે, ref કૉલરના ચલમાં ફેરફાર કરવા સક્ષમ કરે છે, અને in કામગીરી માટે મોટી સ્ટ્રક્ટ્સને સંદર્ભ દ્વારા પાસ કરે છે.
આનો અર્થ આવતું — મેથડ્સ, પેરામીટર સુવિધાઓ (વૈકલ્પિક/નામિત/params), ગતિશીલ API માટે ઓવરલોડીંગ, અને ref/out/in મોડિફાયર્સ (ખાસ કરીને out-આધારિત TryParse રૂઢિમત) — બંને C# મેથડ્સ લખવા અને ઘણા .NET API ને ઉપયોગ કરવા માટે મૌલિક છે જે આ સુવિધાઓ પર આધાર રાખે છે.
મેથડ્સ અને તેમના પેરામીટર્સ સમસ્ત C# કોડમાં કેન્દ્રીય હોવાથી, અને ઓવરલોડીંગ, વૈકલ્પિક પેરામીટર્સ અને TryX પેટર્ન જેવી સુવિધાઓ સતત દેખાતી હોવાથી, તેમાં માસ્ટરી મેળવવું અસરકારક C# વિકાસ માટે મૂળ, જરૂરી જ્ઞાન છે.