C# Language
methoden

Een methode verklaren

Elke methode heeft een unieke handtekening die bestaat uit een accessor ( public , private , ...), optionele modifier ( abstract ), een naam en indien nodig methodeparameters. Merk op dat het retourtype geen deel uitmaakt van de handtekening. Een methode-prototype ziet er als volgt uit:

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

AccessModifier kan public , protected , pirvate of standaard internal .

OptionalModifier kan static abstract virtual override new of sealed .

ReturnType kan void voor geen terugkeer of kan elk type zijn, van de basis, als int tot complexe klassen.

een methode kan enkele of geen invoerparameters hebben. om parameters voor een methode in te stellen, moet u elk verklaren zoals normale variabele declaraties (zoals int a ), en voor meer dan één parameter moet u komma ertussen gebruiken (zoals int a, int b ).

Parameters kunnen standaardwaarden hebben. hiervoor moet u een waarde instellen voor de parameter (zoals int a = 0 ). als een parameter een standaardwaarde heeft, is het instellen van de invoerwaarde optioneel.

Het volgende methode-voorbeeld retourneert de som van twee gehele getallen:

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

Een methode aanroepen

Een statische methode oproepen:

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

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

Een statische methode oproepen en de retourwaarde opslaan:

string input = System.Console.ReadLine();

Een instantiemethode oproepen:

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

Een generieke methode aanroepen

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

Parameters en argumenten

Een methode kan een willekeurig aantal parameters declareren (in dit voorbeeld zijn i , s en o de parameters):

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

Parameters kunnen worden gebruikt om waarden door te geven aan een methode, zodat de methode ermee kan werken. Dit kan elk soort werk zijn, zoals het afdrukken van de waarden of het aanbrengen van wijzigingen in het object waarnaar wordt verwezen door een parameter, of het opslaan van de waarden.

Wanneer u de methode aanroept, moet u voor elke parameter een werkelijke waarde doorgeven. Op dit punt worden de waarden die u daadwerkelijk doorgeeft aan de methode-aanroep argumenten genoemd:

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

Retourtypen

Een methode kan niets ( void ) of een waarde van een opgegeven type retourneren:

// 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";
}

Als uw methode beschrijft een return waarde, moet de methode een waarde terug te keren. U doet dit met behulp van de return statement. Zodra een return is bereikt, retourneert deze de opgegeven waarde en elke code nadat deze niet meer wordt uitgevoerd (uitzonderingen zijn finally blokken, die nog steeds worden uitgevoerd voordat de methode terugkeert).

Als uw methode niets retourneert ( void ), kunt u nog steeds de instructie return zonder waarde gebruiken als u onmiddellijk wilt terugkeren uit de methode. Aan het einde van een dergelijke methode zou een return echter niet nodig zijn.

Voorbeelden van geldige return :

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

Door een uitzondering te maken, kan de uitvoering van de methode worden beëindigd zonder een waarde te retourneren. Er zijn ook iteratorblokken, waar retourwaarden worden gegenereerd met behulp van het opbrengstwoord, maar dat zijn speciale gevallen die op dit punt niet worden uitgelegd.

Standaard parameters

U kunt standaardparameters gebruiken als u de optie wilt bieden om parameters weg te laten:

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")
}

Wanneer u een dergelijke methode aanroept en een parameter weglaat waarvoor een standaardwaarde is opgegeven, voegt de compiler die standaardwaarde voor u in.

Houd er rekening mee dat parameters met standaardwaarden achter parameters zonder standaardwaarden moeten worden geschreven.

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);
    }   

WAARSCHUWING : Omdat het op die manier werkt, kunnen standaardwaarden in sommige gevallen problematisch zijn. Als u de standaardwaarde van een parameterparameter wijzigt en niet alle bellers van die methode opnieuw compileert, gebruiken die bellers nog steeds de standaardwaarde die aanwezig was toen ze werden gecompileerd, wat mogelijk inconsistenties veroorzaakte.

Methode overbelasting

Definitie: Wanneer meerdere methoden met dezelfde naam met verschillende parameters worden gedeclareerd, wordt dit methode-overbelasting genoemd. Methodeoverbelasting vertegenwoordigt meestal functies die identiek zijn in hun doel, maar zijn geschreven om verschillende gegevenstypen als hun parameters te accepteren.

Factoren die beïnvloeden

• Aantal argumenten
• Soort argumenten
• Retourtype **

Overweeg een methode met de naam Area die rekenfuncties uitvoert, die verschillende argumenten accepteert en het resultaat retourneert.

Voorbeeld

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

Deze methode accepteert één argument en retourneert een tekenreeks, als we de methode met een geheel getal (bijvoorbeeld 5 ) aanroepen, is de uitvoer "Area of Square is 25" .

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

Evenzo, als we twee dubbele waarden aan deze methode doorgeven, zal de uitvoer het product van de twee waarden zijn en van het type dubbel zijn. Dit kan worden gebruikt voor vermenigvuldiging en voor het vinden van het gebied met rechthoeken

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

Dit kan speciaal worden gebruikt voor het vinden van het cirkelgebied, dat een dubbele waarde ( radius ) accepteert en een andere dubbele waarde als het gebied retourneert.

Elk van deze methoden kan normaal zonder conflict worden aangeroepen - de compiler onderzoekt de parameters van elke methodeaanroep om te bepalen welke versie van Area moet worden gebruikt.

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

** Merk op dat het retourtype alleen geen onderscheid kan maken tussen twee methoden. Als we bijvoorbeeld twee definities hadden voor Gebied met dezelfde parameters, zoals hier:

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

Als onze klasse dezelfde methoden moet gebruiken die verschillende waarden retourneren, kunnen we de problemen van dubbelzinnigheid oplossen door een interface te implementeren en het gebruik ervan expliciet te definiëren.

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) { ... }

Anonieme methode

Anonieme methoden bieden een techniek om een codeblok door te geven als een gedelegeerde parameter. Het zijn methoden met een lichaam, maar geen naam.

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));
    }
}

Toegangsrechten

// 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()