Metoder är funktioner som definieras i en klass. C# stöder omfattande parameterfunktioner — valfria/namngivna argument, ref/out/in-modifierare, -matriser — och (flera metoder med samma namn men olika parametrar).
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
Metoder anger en returtyp, namn och parametrar. Standardparametrar gör argument valfria, och namngivna argument låter dig skicka efter namn (tydligare, kan hoppa över valfria).
// 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 används i stor utsträckning i TryParse-mönstret (returnerar en framgångsflagga plus resultatet på ett säkert sätt); ref tillåter ändring av anroparens variabel; in skickar stora structs effektivt utan kopiering.
// 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
Överlagring låter flera metoder dela ett namn, åtskilda av parametertyper/antal — kompilatorn väljer den matchande. params accepterar ett varierande antal argument.
Metoder är byggstenarna för beteende i C#, och att förstå deras omfattande parameterfunktioner är viktigt för att skriva flexibel, uttrycksfull kod.
Att veta hur man definierar metoder (inklusive kortfattad expression-bodied-syntax), använder standardparametrar och namngivna parametrar (för valfria argument och läsbara anrop) och tillämpar metodöverlagring (samma namn, olika parametrar — för intuitiva API:er som hanterar olika argumenttyper) är vardagskunskap.
Parametermodifierarna är särskilt viktiga att förstå: out används i stor utsträckning i det allmänna TryParse-mönstret (int.TryParse(s, out var result) — returnerar säkert en framgångsflagga och resultat utan undantag, ett vanligt, idiomatiskt C#-mönster), ref möjliggör ändring av anroparens variabel, och in skickar stora structs efter referens för prestanda.
Att förstå dessa — metoder, parameterfunktionerna (valfria/namngivna/params), överlagring för flexibla API:er och ref/out/in-modifierarna (särskilt out-baserade TryParse-idiom) — är grundläggande för både att skriva C#-metoder och att använda de många .NET API:er som förlitar sig på dessa funktioner.
Eftersom metoder och deras parametrar är centrala för all C#-kod, och eftersom funktioner som överlagring, valfria parametrar och TryX-mönstret förekommer konstant, är det en kärnkunskap och måste-veta-kunskap för effektiv C#-utveckling att behärska dem.
Ett bibliotek med IT-intervjufrågor och detaljerade svar — från Junior till Senior.
Donera