C# Language
Methoden

Eine Methode deklarieren

Jede Methode verfügt über eine eindeutige Signatur, die aus einem Zugriffsmechanismus ( public , private , ...), einem optionalen Modifikator ( abstract ), einem Namen und bei Bedarf Methodenparametern besteht. Beachten Sie, dass der Rückgabetyp nicht Teil der Signatur ist. Ein Methodenprototyp sieht wie folgt aus:

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

AccessModifier kann public , protected , pirvate oder standardmäßig internal .

OptionalModifier kann eine static abstract virtual override new oder sealed .

ReturnType kann für keine Rückgabe void oder es kann ein beliebiger Typ von den grundlegenden Typen sein, wie int bis zu komplexen Klassen.

Eine Methode kann einige oder keine Eingabeparameter haben. Um Parameter für eine Methode festzulegen, sollten Sie jede wie normale Variablendeklarationen deklarieren (wie int a ), und für mehrere Parameter sollten Sie ein Komma zwischen ihnen verwenden (wie int a, int b ).

Parameter können Standardwerte haben. Dazu sollten Sie einen Wert für den Parameter einstellen (wie int a = 0 ). Wenn ein Parameter einen Standardwert hat, ist die Einstellung des Eingabewerts optional.

Das folgende Methodenbeispiel gibt die Summe zweier Ganzzahlen zurück:

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

Methode aufrufen

Eine statische Methode aufrufen:

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

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

Eine statische Methode aufrufen und ihren Rückgabewert speichern:

string input = System.Console.ReadLine();

Aufruf einer Instanzmethode:

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

Eine generische Methode aufrufen

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

Parameter und Argumente

Eine Methode kann eine beliebige Anzahl von Parametern deklarieren (in diesem Beispiel sind i , s und o die Parameter):

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

Mithilfe von Parametern können Werte an eine Methode übergeben werden, sodass die Methode damit arbeiten kann. Dies kann jede Art von Arbeit sein, z. B. das Drucken der Werte oder das Ändern von Objekten, auf die ein Parameter verweist, oder das Speichern der Werte.

Wenn Sie die Methode aufrufen, müssen Sie für jeden Parameter einen tatsächlichen Wert übergeben. An diesem Punkt werden die Werte, die Sie tatsächlich an den Methodenaufruf übergeben, als Argumente bezeichnet:

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

Rückgabewerte

Eine Methode kann entweder nichts ( void ) oder einen Wert eines angegebenen Typs zurückgeben:

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

Wenn Ihre Methode einen Rückgabewert angibt, muss die Methode einen Wert zurückgeben. Sie machen dies mit der return Anweisung. Sobald eine return Anweisung erreicht ist, gibt sie den angegebenen Wert und den Code zurück, der nicht mehr ausgeführt wird (Ausnahmen sind finally Blöcke, die noch ausgeführt werden, bevor die Methode zurückkehrt).

Wenn Ihre Methode nichts ( void ) zurückgibt, können Sie die return Anweisung immer noch ohne Wert verwenden, wenn Sie die Methode sofort zurückgeben möchten. Am Ende einer solchen Methode wäre eine return Anweisung jedoch nicht erforderlich.

Beispiele für gültige return :

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

Durch das Auslösen einer Ausnahme kann die Ausführung der Methode beendet werden, ohne dass ein Wert zurückgegeben wird. Es gibt auch Iteratorblöcke, in denen Rückgabewerte mithilfe des Schlüsselworts „yield“ generiert werden. Dies sind jedoch Sonderfälle, die an dieser Stelle nicht erläutert werden.

Standardparameter

Sie können Standardparameter verwenden, wenn Sie die Option zum Auslassen von Parametern angeben möchten:

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

Wenn Sie eine solche Methode aufrufen und einen Parameter auslassen, für den ein Standardwert bereitgestellt wird, fügt der Compiler diesen Standardwert für Sie ein.

Beachten Sie, dass Parameter mit Standardwerten nach Parametern ohne Standardwerte geschrieben werden müssen.

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

WARNUNG : Da dies so funktioniert, können Standardwerte in einigen Fällen problematisch sein. Wenn Sie den Standardwert eines Methodenparameters ändern und nicht alle Aufrufer dieser Methode neu kompilieren, verwenden diese Anrufer weiterhin den Standardwert, der beim Kompilieren vorhanden war, was zu Inkonsistenzen führen kann.

Überladung der Methode

Definition: Wenn mehrere Methoden mit demselben Namen mit unterschiedlichen Parametern deklariert werden, spricht man von Methodenüberladung. Das Überladen von Methoden stellt normalerweise Funktionen dar, die in ihrem Zweck identisch sind, jedoch so geschrieben werden, dass sie unterschiedliche Datentypen als Parameter akzeptieren.

Beeinflussende Faktoren

• Anzahl der Argumente
• Art der Argumente
• Rückgabetyp **

Stellen Sie sich eine Methode namens Area , die Berechnungsfunktionen ausführt, die verschiedene Argumente akzeptiert und das Ergebnis zurückgibt.

Beispiel

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

Diese Methode akzeptiert ein Argument und gibt einen String zurück. Wenn wir die Methode mit einer Ganzzahl aufrufen (z. B. 5 ), wird die Ausgabe "Area of Square is 25" .

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

Wenn wir dieser Methode zwei doppelte Werte übergeben, ist die Ausgabe das Produkt der beiden Werte und vom Typ double. Dies kann sowohl für die Multiplikation als auch für das Finden der Fläche von Rechtecken verwendet werden

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

Dies kann speziell zum Ermitteln des Kreisbereichs verwendet werden, der einen doppelten Wert ( radius ) akzeptiert und einen anderen doppelten Wert als seinen Bereich zurückgibt.

Jede dieser Methoden kann normalerweise ohne Konflikte aufgerufen werden. Der Compiler überprüft die Parameter jedes Methodenaufrufs, um festzustellen, welche Version von Area verwendet werden muss.

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

** Beachten Sie, dass der Rückgabetyp allein nicht zwischen zwei Methoden unterscheiden kann. Wenn wir zum Beispiel zwei Definitionen für Area hatten, die die gleichen Parameter hatten, wie folgt:

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

Wenn unsere Klasse dieselben Methodennamen verwenden muss, die unterschiedliche Werte zurückgeben, können wir das Problem der Mehrdeutigkeit beseitigen, indem Sie eine Schnittstelle implementieren und deren Verwendung explizit definieren.

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

Anonyme Methode

Anonyme Methoden bieten eine Technik zum Übergeben eines Codeblocks als Delegatparameter. Sie sind Methoden mit Körper, aber ohne Namen.

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

Zugangsrechte

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