Lernen Sie C#

Methoden verstehen und C#-Erweiterungsmethoden verwenden

Tim Corey

28m 27s

In der C#-Programmierung sind Methoden wichtige Bausteine, die wiederverwendbaren Code kapseln und bestimmte Aufgaben ausführen. Sie können Parameter akzeptieren, Werte zurückgeben und überladen werden, um unterschiedliche Eingaben zu verarbeiten. Erweiterungsmethoden sind ein fortgeschrittenes Konzept, das es Entwicklern ermöglicht, bestehende Typen um Funktionen zu erweitern, auch solche, die sie nicht kontrollieren.

Tim Corey's Video 'How To Create Extension Methods in C#' ist eine ausgezeichnete Quelle. In diesem Leitfaden werden wir verschiedene Themen behandeln, die Tim abdeckt:

Definieren und Aufrufen von Methoden
Methodenparameter und Argumente
Rückgabewerte von Methoden
Überladen von Methoden
Implementierung von Erweiterungsmethoden

Definieren und Aufrufen von Methoden

Instanzmethoden definiert

In C# wird eine Methode innerhalb einer Klasse definiert. Die allgemeine Syntax für eine Methodendefinition umfasst einen Zugriffsmodifikator, einen Rückgabetyp, einen Methodennamen und Parameter.

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }
}

public class SampleClass
{
    public void SampleMethod()
    {
        // Method implementation  
    }
}

Public Class SampleClass
    Public Sub SampleMethod()
        ' Method implementation  
    End Sub
End Class

Public Class SampleClass
    Public Sub SampleMethod()
        ' Method implementation  
    End Sub
End Class

Im Beispiel von Tim Corey bei 4:05 definiert er eine Methode innerhalb einer statischen Klasse, um eine Erweiterungsmethode zu erstellen. Die definierte Methode ist PrintToConsole. Die Definition umfasst die gesamte allgemeine Syntax, die anhand eines praktischen Beispiels deutlich macht, wie eine Methode zu definieren ist:

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

Public Module Extensions
    <System.Runtime.CompilerServices.Extension> _
    Public Sub PrintToConsole(ByVal message As String)
        Console.WriteLine(message)
    End Sub
End Module

Public Module Extensions
    <System.Runtime.CompilerServices.Extension> _
    Public Sub PrintToConsole(ByVal message As String)
        Console.WriteLine(message)
    End Sub
End Module

Aufruf einer Methode

Ein "Methodenaufruf" weist das Programm an, eine bestimmte Methode auszuführen, die an anderer Stelle im Code definiert ist, um eine vordefinierte Aktion auszuführen. Methoden werden über die Klasseninstanz aufgerufen, oder direkt, wenn es sich um statische Methoden handelt. Erweiterungsmethoden werden so dargestellt, als ob sie Teil des Typs wären, den sie erweitern. In dem Video bei 6:18 zeigt Tim, wie man eine Erweiterungsmethode mit einem primitiven Datentyp genau wie die vordefinierten Methoden aufruft.

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

string demo = "This is a demo";
demo.PrintToConsole(); // Extension method call

Dim demo As String = "This is a demo"
demo.PrintToConsole() ' Extension method call

Dim demo As String = "This is a demo"
demo.PrintToConsole() ' Extension method call

Methodenparameter und Argumente

Parameter

Parameter werden in der Methodendefinition angegeben und dienen als Platzhalter für die Werte, die an die Methode übergeben werden. Sie können es hier sehen, nachdem die Methode WriteLine aufgerufen wurde, wobei message der Parameter ist.

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

public void DisplayMessage(string message)
{
    Console.WriteLine(message);
}

Public Sub DisplayMessage(message As String)
    Console.WriteLine(message)
End Sub

Public Sub DisplayMessage(message As String)
    Console.WriteLine(message)
End Sub

Wiederum, im Beispiel für die Erweiterungsmethode, das Tim Corey um 4:05 gegeben hat, ist message der Parameter:

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

public static void PrintToConsole(this string message)
{
    Console.WriteLine(message);
}

<Extension()>
Public Sub PrintToConsole(ByVal message As String)
    Console.WriteLine(message)
End Sub

<Extension()>
Public Sub PrintToConsole(ByVal message As String)
    Console.WriteLine(message)
End Sub

Argumente

Argumente sind die tatsächlichen Werte, die der Methode beim Aufruf übergeben werden.

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

DisplayMessage("Hello, World!"); // "Hello, World!" is the argument

DisplayMessage("Hello, World!") ' "Hello, World!" is the argument

DisplayMessage("Hello, World!") ' "Hello, World!" is the argument

Wenn Tim Corey die Methode um 6:20 unter Verwendung der Punkt-Syntax mit dem String-Typ aufruft, wird der String-Wert tatsächlich als Wert an die Methode PrintToConsole übergeben:

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

string demo = "This is a demo";
demo.PrintToConsole(); // "This is a demo" is the argument

Dim demo As String = "This is a demo"
demo.PrintToConsole() ' "This is a demo" is the argument

Dim demo As String = "This is a demo"
demo.PrintToConsole() ' "This is a demo" is the argument

Methodenrückgabewerte

Methoden können mit der return-Anweisung Werte zurückgeben. Der Rückgabetyp wird in der Methodensignatur angegeben.

public int Add(int a, int b)
{
    return a + b;
}

public int Add(int a, int b)
{
    return a + b;
}

Public Function Add(a As Integer, b As Integer) As Integer
    Return a + b
End Function

Public Function Add(a As Integer, b As Integer) As Integer
    Return a + b
End Function

Während die Erweiterungsmethode im Video von Tim Corey keinen Wert zurückgibt (Rückgabetyp void), können Sie Erweiterungsmethoden mit Rückgabewerten erstellen. Der Rückgabetyp in Tims Beispiel ist void, was bedeutet, dass die Methode keinen Wert zurückgibt. Das folgende Beispiel zeigt, wie man einen Wert zurückgibt:

public static int WordCount(this string str)
{
    return str.Split(' ').Length;
}

public static int WordCount(this string str)
{
    return str.Split(' ').Length;
}

<Extension()>
Public Function WordCount(ByVal str As String) As Integer
    Return str.Split(" "c).Length
End Function

<Extension()>
Public Function WordCount(ByVal str As String) As Integer
    Return str.Split(" "c).Length
End Function

Methodenüberladung (11:15)

Das Überladen von Methoden ermöglicht es, dass mehrere Methoden denselben Namen, aber unterschiedliche Parameter haben. Dies kann für die Erstellung flexibler und intuitiver APIs nützlich sein.

public void Display(string message)
{
    Console.WriteLine(message);
}

public void Display(int number)
{
    Console.WriteLine(number);
}

public void Display(string message)
{
    Console.WriteLine(message);
}

public void Display(int number)
{
    Console.WriteLine(number);
}

Public Sub Display(message As String)
    Console.WriteLine(message)
End Sub

Public Sub Display(number As Integer)
    Console.WriteLine(number)
End Sub

Public Sub Display(message As String)
    Console.WriteLine(message)
End Sub

Public Sub Display(number As Integer)
    Console.WriteLine(number)
End Sub

Tim Corey geht bei 11:24 kurz auf die Erstellung mehrerer Methoden für verschiedene Protokollierungsszenarien ein, was als Beispiel für das Überladen von Methoden im weiteren Sinne angesehen werden kann. Die Log-Methode gibt es zweimal, einmal mit einem Parameter und einmal mit zwei Parametern. Die zweite Log-Methode bei 11:39 ist die überladene Version der Log-Methode, die unter demselben Namen mehrere Funktionen bietet.

Implementing Extension Methods in C#

Was sind Erweiterungsmethoden? (3:13)

Erweiterungsmethoden ermöglichen es Ihnen, neue Methoden zu bestehenden Typen hinzuzufügen, ohne diese ändern oder neu kompilieren zu müssen. Während sie als Instanzmethoden bezeichnet werden, sind Erweiterungsmethoden als statisch definiert.

Erstellen einer Erweiterungsmethode

Im vorangegangenen Abschnitt "Definieren und Aufrufen von Methoden" haben wir gezeigt, wie Tim Corey eine Erweiterungsmethode in einer separaten statischen Klasse erstellt und die statische Methode innerhalb dieser Klasse als Erweiterungsmethode definiert hat. Hier sind einige wichtige Punkte, die Tim Corey hervorhebt:

Achten Sie darauf, eine separate öffentliche statische Klasse zu definieren, oder, wie Tim sagt, "markieren Sie die Klasse als statisch, sonst wird sie nicht funktionieren."
Wenn Sie mehr Erweiterungsmethoden erstellen, gruppieren Sie sie nach Typ (3:43)
Definieren Sie eine statische Methode mit dem ersten Parameter, der mit dem Schlüsselwort this versehen ist und den Typ zur Erweiterung angibt (4:58).

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

public static class Extensions
{
    public static void PrintToConsole(this string message)
    {
        Console.WriteLine(message);
    }
}

Public Module Extensions
    <System.Runtime.CompilerServices.Extension> _
    Public Sub PrintToConsole(ByVal message As String)
        Console.WriteLine(message)
    End Sub
End Module

Public Module Extensions
    <System.Runtime.CompilerServices.Extension> _
    Public Sub PrintToConsole(ByVal message As String)
        Console.WriteLine(message)
    End Sub
End Module

Aufruf der Erweiterungsmethode (6:18)

Als nächstes zeigt Tim, wie man eine Erweiterungsmethode für diese String-Variable aufruft:

demo.PrintToConsole();

demo.PrintToConsole();

demo.PrintToConsole()

demo.PrintToConsole()

Wenn Sie demo eingeben und mit dem Tippen von Print beginnen, schlägt IntelliSense die Methode PrintToConsole vor. Dies ist die neue Methode, die dem Typ string hinzugefügt wurde.

Wie der Methodenaufruf funktioniert (6:30)

Tim erklärt, warum Sie demo.PrintToConsole() anrufen können:

Demo ist ein String-Typ: Die Variable demo ist vom Typ string.
Erweiterter String-Typ: Der Typ string wurde mit der neuen Methode PrintToConsole erweitert.

Verständnis des Parameters (6:41)

Obwohl es scheint, dass keine Parameter an die Methode PrintToConsole übergeben werden, weist Tim auf die implizite Parameterübergabe hin - der demo-String wird als erster Parameter an die Erweiterungsmethode übergeben.

Tim betont, dass Erweiterungsmethoden beim Aufruf einen Parameter weniger haben als in ihrer Definition. Dies liegt daran, dass der erste Parameter (der zu erweiternde Typ) implizit ist.

Erweiterung Methodensignatur

Hier bedeutet this string message, dass die Methode den Typ string erweitert, und message ist der implizite Parameter:

public static void PrintToConsole(this string message)

public static void PrintToConsole(this string message)

<Extension()>
Public Sub PrintToConsole(ByVal message As String)

<Extension()>
Public Sub PrintToConsole(ByVal message As String)

Ausführen des Codes (7:08)

Schließlich, wenn die Methode PrintToConsole aufgerufen wird, gibt sie den String in der Konsole aus:

Console.WriteLine(message);

Console.WriteLine(message);

Console.WriteLine(message)

Console.WriteLine(message)

Das Aufrufen von demo.PrintToConsole() druckt also "Dies ist eine Demo" in der Konsole.

Verwendung von Erweiterungsmethoden für Klassen von Drittanbietern

Erweiterung von Drittanbieter-Klassen (10:59)

Tim Corey erklärt, dass Erweiterungsmethoden jeden Typ erweitern können, sogar Klassen von Drittanbietern, die Sie nicht direkt ändern können. Zum Beispiel, schauen wir uns die Klasse SimpleLogger um 11:09 an.

Hier verwendet Tim die hypothetische Drittanbieterklasse SimpleLogger, die Nachrichten in der Konsole protokolliert (11:09). Die Klasse hat zwei Methoden:

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

public class SimpleLogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }

    public void Log(string message, string messageType)
    {
        Console.WriteLine($"{messageType}: {message}");
    }
}

Public Class SimpleLogger
    Public Sub Log(message As String)
        Console.WriteLine(message)
    End Sub

    Public Sub Log(message As String, messageType As String)
        Console.WriteLine($"{messageType}: {message}")
    End Sub
End Class

Public Class SimpleLogger
    Public Sub Log(message As String)
        Console.WriteLine(message)
    End Sub

    Public Sub Log(message As String, messageType As String)
        Console.WriteLine($"{messageType}: {message}")
    End Sub
End Class

Diese Methoden sind nicht ideal, da der Nachrichtentyp eine einfache Zeichenkette ist, was zu Inkonsistenzen führen kann. Tim schlägt vor, Erweiterungsmethoden zu erstellen, um die Klasse zu verbessern.

Implementierung konsistenter Nachrichtentypen

Die Verwendung von Erweiterungsmethoden sorgt für Konsistenz in Ihrem Code, da immer dieselben Nachrichtentypen und Formatierungen verwendet werden. Hier um (12:40) erstellt Tim eine statische Klasse ExtendSimpleLogger:

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }
   
    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

public static class ExtendSimpleLogger
{
    public static void LogError(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Error");
    }
   
    public static void LogWarning(this SimpleLogger logger, string message)
    {
        logger.Log(message, "Warning");
    }
}

Public Module ExtendSimpleLogger
    <System.Runtime.CompilerServices.Extension> 
    Public Sub LogError(ByVal logger As SimpleLogger, ByVal message As String)
        logger.Log(message, "Error")
    End Sub

    <System.Runtime.CompilerServices.Extension> 
    Public Sub LogWarning(ByVal logger As SimpleLogger, ByVal message As String)
        logger.Log(message, "Warning")
    End Sub
End Module

Public Module ExtendSimpleLogger
    <System.Runtime.CompilerServices.Extension> 
    Public Sub LogError(ByVal logger As SimpleLogger, ByVal message As String)
        logger.Log(message, "Error")
    End Sub

    <System.Runtime.CompilerServices.Extension> 
    Public Sub LogWarning(ByVal logger As SimpleLogger, ByVal message As String)
        logger.Log(message, "Warning")
    End Sub
End Module

Aufrufe konsistenter gestalten

Mit dieser in der Hand kann er nun um (14:02) die Erweiterungsmethoden auf einer SimpleLogger-Instanz aufrufen:

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

SimpleLogger logger = new SimpleLogger();
logger.LogError("This is an error");
logger.LogWarning("This is a warning");

Dim logger As New SimpleLogger()
logger.LogError("This is an error")
logger.LogWarning("This is a warning")

Dim logger As New SimpleLogger()
logger.LogError("This is an error")
logger.LogWarning("This is a warning")

Dadurch wird sichergestellt, dass die Meldungstypen immer "Fehler" und "Warnung" sind.

Verbesserung der Ausgabeformatierung (14:35)

Tim fügt die Funktionalität hinzu, die Konsolentextfarbe für Fehlermeldungen einzustellen, um sicherzustellen, dass sie hervorstechen:

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

public static void LogError(this SimpleLogger logger, string message)
{
    var defaultColor = Console.ForegroundColor;
    Console.ForegroundColor = ConsoleColor.Red;
    logger.Log(message, "Error");

    Console.ForegroundColor = defaultColor;
}

<Extension()>
Public Sub LogError(ByVal logger As SimpleLogger, ByVal message As String)
    Dim defaultColor = Console.ForegroundColor
    Console.ForegroundColor = ConsoleColor.Red
    logger.Log(message, "Error")

    Console.ForegroundColor = defaultColor
End Sub

<Extension()>
Public Sub LogError(ByVal logger As SimpleLogger, ByVal message As String)
    Dim defaultColor = Console.ForegroundColor
    Console.ForegroundColor = ConsoleColor.Red
    logger.Log(message, "Error")

    Console.ForegroundColor = defaultColor
End Sub

Vergleich mit direkten Methodenaufrufen (17:21)

Tim vergleicht diesen Ansatz mit dem direkten Aufruf der ursprünglichen Log-Methoden, die zu Inkonsistenzen führen könnten:

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

logger.Log("Test error", "Error");
logger.Log("Another error", "ERROR");

logger.Log("Test error", "Error")
logger.Log("Another error", "ERROR")

logger.Log("Test error", "Error")
logger.Log("Another error", "ERROR")

Dieser Ansatz ist anfällig für Tippfehler und inkonsistente Formatierungen.

Erweiterungsmethoden verketten (18:13)

Tim zeigt, wie Erweiterungsmethoden verkettet werden können, um den Code besser lesbar zu machen:

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

public static void LogInfo(this SimpleLogger logger, string message)
{
    logger.Log(message, "Info");
}

public static void SaveToDatabase(this SimpleLogger logger)
{
    // Simulate saving to a database
}

Public Sub LogInfo(ByVal logger As SimpleLogger, ByVal message As String)
    logger.Log(message, "Info")
End Sub

Public Sub SaveToDatabase(ByVal logger As SimpleLogger)
    ' Simulate saving to a database
End Sub

Public Sub LogInfo(ByVal logger As SimpleLogger, ByVal message As String)
    logger.Log(message, "Info")
End Sub

Public Sub SaveToDatabase(ByVal logger As SimpleLogger)
    ' Simulate saving to a database
End Sub

Jetzt können Sie diese Methoden verketten:

logger.LogInfo("Information").SaveToDatabase();

logger.LogInfo("Information").SaveToDatabase();

logger.LogInfo("Information").SaveToDatabase()

logger.LogInfo("Information").SaveToDatabase()

Dadurch wird der Code im Vergleich zu verschachtelten Methodenaufrufen besser lesbar und intuitiv:

SaveToDatabase(LogInfo(logger, "Information"));

SaveToDatabase(LogInfo(logger, "Information"));

SaveToDatabase(LogInfo(logger, "Information"))

SaveToDatabase(LogInfo(logger, "Information"))

Durch die Verwendung von Punktnotation und Verkettung wird die Absicht des Codes klarer und weniger verschachtelt.

Erweiterung von Dingen, die Sie nicht besitzen

Bei 20:13 erklärt Tim Corey, dass Erweiterungsmethoden ideal sind, um Funktionalität zu Klassen hinzuzufügen, die Sie nicht besitzen, wie z. B. Bibliotheken von Drittanbietern. So können Verbesserungen vorgenommen werden, ohne den ursprünglichen Code zu verändern.

Abhängigkeiten vermeiden

Corey hebt auch die Verwendung von Erweiterungsmethoden hervor, um Abhängigkeiten einzuführen, ohne sie direkt an eine Klasse zu koppeln. Zum Beispiel das Hinzufügen von Datenbankspeicherfunktionen zu einer Person-Klasse ohne Einbettung der Datenbanklogik.

Schnittstellen erweitern

Erweiterungsmethoden können auch auf Schnittstellen angewendet werden, wie ab 21:30 Uhr erklärt wird, so dass mehrere Klassen, die die Schnittstelle implementieren, dieselbe Funktionalität nutzen können. Dies fördert die Wiederverwendung und Vereinfachung von Code.

Wann man Erweiterungsmethoden nicht verwenden sollte

Bei 23:03 rät Tim Corey von der übermäßigen Verwendung von Erweiterungsmethoden ab, insbesondere bei primitiven oder von Microsoft bereitgestellten Typen, um Unordnung und Komplexität zu vermeiden. Verwenden Sie sie sparsam und nur dann, wenn sie klare Vorteile bieten.

Das Offen/Geschlossen-Prinzip

Im Abschnitt zwischen 24:54 und 25:40 betont Tim die Einhaltung des Open/Closed-Prinzips, indem er Erweiterungsmethoden einsetzt, um neue Funktionen hinzuzufügen, ohne bestehenden, stabilen Code zu ändern, wodurch das Risiko der Einführung von Fehlern verringert wird.

Best Practices für die Verwendung von Statements

Organisieren Sie Erweiterungsmethoden, indem Sie sie logisch gruppieren und in separaten Namensräumen unterbringen, um Benennungskonflikte zu vermeiden und die Wartung und Fehlersuche zu erleichtern.

Abschluss

Sie verstehen nun die Grundlagen der Definition und des Aufrufs von Methoden, den Umgang mit Parametern und Rückgabewerten und die Nutzung von Methodenüberladung. Damit können Sie robuste und flexible Anwendungen in C# erstellen.

Erweiterungsmethoden, wie sie von Tim Corey erklärt werden, bieten eine leistungsstarke Möglichkeit, bestehende Typen zu verbessern und den Code lesbarer und wartbarer zu machen. Detailliertere Einblicke und praktische Beispiele finden Sie in Tim Coreys vollständigem Video zu How To Create Extension Methods in C#.

Earn More by Sharing What You Love

Do you create content for developers working with .NET, C#, Java, Python, or Node.js? Turn your expertise into extra income!

Join our Affiliate program

Let's Stay in Touch!

Join our newsletter, you’ll get exclusive access on article updates. We value your privacy