C# Language
metoder

Förklara en metod

Varje metod har en unik signatur som består av en accessor ( public , private , ...), valfri modifierare ( abstract ), ett namn och metodparametrar om det behövs. Observera att returtypen inte är en del av signaturen. En metodprototyp ser ut enligt följande:

AccessModifier OptionalModifier ReturnType MethodName(InputParameters)
{
    //Method body
}

AccessModifier kan vara public , protected , pirvate eller som standard internal .

OptionalModifier kan vara static abstract virtual override new eller sealed .

ReturnType kan vara void utan återkomst eller kan vara vilken typ som helst från de grundläggande, som int till komplexa klasser.

en metod kan ha några eller inga ingångsparametrar. För att ställa in parametrar för en metod, bör du förklara var och en som normala variabla deklarationer (som int a ), och för mer än en parameter bör du använda komma mellan dem (som int a, int b ).

Parametrar kan ha standardvärden. för detta bör du ställa in ett värde för parametern (som int a = 0 ). om en parameter har ett standardvärde är inställning av ingångsvärdet valfritt.

Följande metodexempel returnerar summan av två heltal:

private int Sum(int a, int b)
{
    return a + b;
} 

Ringa en metod

Ringa en statisk metod:

// Single argument
System.Console.WriteLine("Hello World");  

// Multiple arguments
string name = "User";
System.Console.WriteLine("Hello, {0}!", name);  

Ringa en statisk metod och lagra dess returvärde:

string input = System.Console.ReadLine();

Ringa en instansmetod:

int x = 42;
// The instance method called here is Int32.ToString()
string xAsString = x.ToString();

Att kalla en generisk metod

// Assuming a method 'T[] CreateArray<T>(int size)'
DateTime[] dates = CreateArray<DateTime>(8);

Parametrar och argument

En metod kan deklarera valfritt antal parametrar (i detta exempel är i , s och o parametrarna):

static void DoSomething(int i, string s, object o) {
    Console.WriteLine(String.Format("i={0}, s={1}, o={2}", i, s, o));
}

Parametrar kan användas för att överföra värden till en metod, så att metoden kan fungera med dem. Detta kan vara varje slags arbete som att skriva ut värden eller göra ändringar av objektet som en parameter refererar till, eller lagra värdena.

När du anropar metoden måste du skicka ett faktiskt värde för varje parameter. Vid denna punkt kallas värdena som du faktiskt överför till metodsamtalet Argument:

DoSomething(x, "hello", new object());

Returtyper

En metod kan returnera antingen ingenting ( void ) eller ett värde av en specifik typ:

// If you don't want to return a value, use void as return type.
static void ReturnsNothing() { 
    Console.WriteLine("Returns nothing");
}

// If you want to return a value, you need to specify its type.
static string ReturnsHelloWorld() {
    return "Hello World";
}

Om din metod anger ett returvärde måste metoden returnera ett värde. Detta gör du med hjälp av return uttalande. När en return uttalande har nåtts, återgår det angivna värdet och någon kod efter det inte kommer att köras längre (undantagen är finally block, som fortfarande kommer att utföras innan metoden avkastning).

Om metoden returnerar ingenting ( void ), kan du fortfarande använda return uttalande utan ett värde om du vill återvända från metoden omedelbart. I slutet av en sådan metod, en return skulle uttalande vara onödigt om.

Exempel på giltiga return uttalanden:

return; 
return 0; 
return x * 2;
return Console.ReadLine();

Att kasta ett undantag kan avsluta metodutförandet utan att returnera ett värde. Det finns också iteratorblock, där returvärden genereras med hjälp av avkastningsnyckelordet, men det är speciella fall som inte kommer att förklaras vid denna punkt.

Standardparametrar

Du kan använda standardparametrar om du vill tillhandahålla alternativet att utelämna parametrar:

static void SaySomething(string what = "ehh") {
    Console.WriteLine(what);
}  

static void Main() {
    // prints "hello"
    SaySomething("hello"); 
    // prints "ehh"
    SaySomething(); // The compiler compiles this as if we had typed SaySomething("ehh")
}

När du kallar en sådan metod och utelämnar en parameter för vilken ett standardvärde tillhandahålls sätter kompilatorn in det standardvärdet för dig.

Tänk på att parametrar med standardvärden måste skrivas efter parametrar utan standardvärden.

static void SaySomething(string say, string what = "ehh") {
        //Correct
        Console.WriteLine(say + what);
    }

static void SaySomethingElse(string what = "ehh", string say) {
        //Incorrect
        Console.WriteLine(say + what);
    }   

VARNING : Eftersom det fungerar på så sätt kan standardvärden vara problematiska i vissa fall. Om du ändrar standardvärdet för en metodparameter och inte sammanställer alla som ringer till den metoden kommer dessa anropare fortfarande att använda standardvärdet som fanns när de kompilerades, vilket kan orsaka inkonsekvenser.

Metodöverbelastning

Definition: När flera metoder med samma namn deklareras med olika parametrar benämns det metodöverbelastning. Metodöverbelastning representerar vanligtvis funktioner som är identiska i deras syfte men skrivna för att acceptera olika datatyper som sina parametrar.

Faktorer som påverkar

• Antal argument
• Typ av argument
• Returtyp **

Tänk på en metod som heter Area som kommer att utföra beräkningsfunktioner, som accepterar olika argument och returnerar resultatet.

Exempel

public string Area(int value1)
{
    return String.Format("Area of Square is {0}", value1 * value1);
}

Denna metod accepterar ett argument och returnerar en sträng, om vi kallar metoden med ett heltal (säg 5 ) kommer utgången att vara "Area of Square is 25" .

public  double Area(double value1, double value2)
{
    return value1 * value2;
}

På samma sätt om vi överför två dubbla värden till denna metod kommer utgången att vara produkten av de två värdena och är av typen dubbel. Detta kan användas för multiplikation såväl som för att hitta området med rektanglar

public double Area(double value1)
{
    return 3.14 * Math.Pow(value1,2);
}

Detta kan användas speciellt för att hitta cirkelområdet, som accepterar ett dubbelvärde ( radius ) och returnerar ytterligare ett dubbelvärde som dess område.

Var och en av dessa metoder kan kallas normalt utan konflikt - kompilatorn undersöker parametrarna för varje metodsamtal för att bestämma vilken version av Area som ska användas.

string squareArea = Area(2);
double rectangleArea = Area(32.0, 17.5);
double circleArea = Area(5.0); // all of these are valid and will compile.

** Observera att returtypen inte bara kan skilja mellan två metoder. Om vi till exempel hade två definitioner för Area som hade samma parametrar, så:

public string Area(double width, double height) { ... }
public double Area(double width, double height) { ... }
// This will NOT compile. 

Om vi behöver vår klass använda samma metodnamn som returnerar olika värden, kan vi ta bort frågorna om tvetydighet genom att implementera ett gränssnitt och uttryckligen definiera dess användning.

public interface IAreaCalculatorString {
    
    public string Area(double width, double height);

}

public class AreaCalculator : IAreaCalculatorString {

    public string IAreaCalculatorString.Area(double width, double height) { ... } 
    // Note that the method call now explicitly says it will be used when called through
    // the IAreaCalculatorString interface, allowing us to resolve the ambiguity.
    public double Area(double width, double height) { ... }

Anonym metod

Anonyma metoder tillhandahåller en teknik för att passera ett kodblock som delegatparameter. Det är metoder med en kropp, men inget namn.

delegate int IntOp(int lhs, int rhs);

class Program
{
    static void Main(string[] args)
    {
        // C# 2.0 definition
        IntOp add = delegate(int lhs, int rhs)
        {
            return lhs + rhs;
        };

        // C# 3.0 definition
        IntOp mul = (lhs, rhs) =>
        {
            return lhs * rhs;
        };

        // C# 3.0 definition - shorthand
        IntOp sub = (lhs, rhs) => lhs - rhs;

        // Calling each method
        Console.WriteLine("2 + 3 = " + add(2, 3));
        Console.WriteLine("2 * 3 = " + mul(2, 3));
        Console.WriteLine("2 - 3 = " + sub(2, 3));
    }
}

Åtkomsträttigheter

// static: is callable on a class even when no instance of the class has been created
public static void MyMethod()

// virtual: can be called or overridden in an inherited class
public virtual  void MyMethod()

// internal: access is limited within the current assembly
internal  void MyMethod()

//private: access is limited only within the same class
private  void MyMethod()

//public: access right from every class / assembly
public void MyMethod()

//protected: access is limited to the containing class or types derived from it
protected void MyMethod()

//protected internal: access is limited to the current assembly or types derived from the containing class.
protected internal void MyMethod()