Vad är en metod?

• Ett sätt att samla en sekvens med satser som utför något specifikt.
• Tillhör alltid en typ, oftast en klass.
• Kan ha vilket antal parametrar som helst, där parametrar används för att ta emot data, argument, från den anropande metoden.
  • Måste anropas med lika många argument som det finns parametrar om ingen parameter är valfri ("optional").
  • Ordningen mellan parametrar kan ändras vid anrop genom att använda namngivna parametrar.
• Kan returnera tillbaka en typ av värde till den metod som anropade metoden.
  • Returtypen void innebär att inget värde kan returneras.
  • Returtypen dynamic innebär att vilken typ som helst kan returneras.

class Program
{
    static void Main()
    {
        string firstName = GetUserInput("Ange ditt förnamn: ");
        string lastName = GetUserInput("Ange ditt efternamn: ");
        // code left out for brevity...
    }
    static string GetUserInput(string prompt)
    {
        Console.Write(prompt);
        return Console.ReadLine();
    }
}

Returvärden

• En metod som inte ska returnerar något värde måste ha returtypen void.
  • En void-metod kan dock innehålla return-sats(er).

static void WriteWeekdayName()
{
    if (DateTime.Today.DayOfWeek == DayOfWeek.Saturday ||
        DateTime.Today.DayOfWeek == DayOfWeek.Sunday)
    {
        return;
    }
    Console.WriteLine($"Dagens namn är {DateTime.Today.ToString("dddd")}."); // Dagens namn är måndag.
}

• En metod som returnerar ett värde måste ha en en returtyp som överensstämmer med värdets typ.

static int GetRandomNumber()
{
    var random = new Random();
    return random.Next(1, 10); // [1, 9]
}

static int GetNumber()
{
    return 3.14; // Error CS0266 Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?)
}

Parametrar

• Samtliga parametrar måste anges, vara i rätt ordning och vara av rätt typ.
  • Använder du namngivna parametrar behöver du inte bry dig om ordningen.

static void Main()
{
    string fullName;
    fullName = GetFullName("Ellen", "Nu"); // Ellen Nu
    fullName = GetFullName(lastName: "Nu", firstName: "Ellen" ); // Ellen Nu
}
static string GetFullName(string firstName, string lastName) => $"{firstName} {lastName}";

• Parametrar som är "optional" kan utelämnas och får då sitt standardvärde.

static void Main()
{
    string fullName;
    fullName = GetFullName(); // N N
    fullName = GetFullName("Ellen"); // Ellen N
    fullName = GetFullName("Ellen", "Nu"); // Ellen Nu
    fullName = GetFullName(lastName: "Nu"); // N Nu
    fullName = GetFullName(lastName: "Nu", firstName: "Ellen"); // Ellen Nu
}
static string GetFullName(string firstName = "N", string lastName = "N") => $"{firstName} {lastName}";

Parameterarrayer

• Genom att låta en parameter vara en parameterarray kan du välja hur många argument som ska användas vid anrop av metoden.
  • Parameterarrayen måste vara den sista parametern i parameterlistan.
  • Argumentet kan vara en array eller en kommaseparerad lista med argument.

    static void Main()
    {
        int sum;
        int[] scores = { 78, 76, 81, 77, 72, 75 };
        sum = Sum(scores); // 459
        sum = Sum(1, 2, 3, 4, 5); // 15
    }
    static int Sum(params int[] numbers)
    {
        int sum = 0;
        foreach (int number in numbers)
        {
            sum += number;
        }
        return sum;
    }

Överlagring ("overloading")

• Metoder kan ha samma namn så länge som de i övrigt har olika signaturer.
  • En signatur är metodens namn, antal parametrar och parameterdatatyper.

static void Main()
{
    int sum = MyMath.Add(123, 456);
    double anotherSum = Add(9.87, 6.54);
    var yetAnotherSum = Add(123, 6.54));
}
public static int Add(int op1, int op2)
{
    return op1 + op2;
}
public static double Add(double op1, double op2)
{
    return op1 + op2;
}

out-parameter

• Genom att använda out för en parameter av värdetyp kan den "göras om" till referenstyp.

static void Main()
{
    if (TryParseOddInt(out int odd))
    {
        Console.WriteLine($"{odd} is an odd number.");
    }
}
static bool TryParseOddInt(out int number)
{
    if (int.TryParse(Console.ReadLine(), out number) && number % 2 == 1)
    {
        return true;
    }
    number = default(int); // 0
    return false;
}

ref-parametrar

• Genom att använda ref för en parameter av värdetyp kan den "göras om" till referenstyp.
• Variabel måste ha ett värde innan anrop av metod med ref-parameter.

static void Main()
{
    int first = 3;
    int second = 42;
    Console.WriteLine($"first: {first}\tsecond: {second}"); // first: 3        second: 42
    Swap(ref first, ref second);
    Console.WriteLine($"first: {first}\tsecond: {second}"); // first: 42       second: 3
}
static void Swap(ref int x, ref int y)
{
    int temp = x;
    x = y;
    y = temp;
}

Returtypen dynamic är "BAD PRACTICE"!

• ...men kan vara användbar.

Tveksam användning...

static void Main()
{
    var bar = Foo(0); // 0, int
    var qux = Foo(1); // Inte noll!, string
}
static dynamic Foo(int i)
{
    if (i == 0)
    {
        return 0;
    }
    return "Inte noll!";
}