Methoden verstehen und C#-Erweiterungsmethoden verwenden

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

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

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

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

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

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

Wenn Tim Corey die Methode um 6:20 mit der Punktsyntax und dem Stringtyp aufruft, wird der Stringwert 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

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:

1. 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."
2. Wenn Sie mehr Erweiterungsmethoden erstellen, gruppieren Sie sie nach Typ (3:43)
3. Definieren Sie eine statische Methode mit dem ersten Parameter, der mit dem Schlüsselwort this versehen ist und den zu erweiternden Typ 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);
    }
}

Aufruf der Erweiterungsmethode (6:18)

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

demo.PrintToConsole();

demo.PrintToConsole();

Wenn Sie demo eingeben und beginnen, Print zu tippen, schlägt IntelliSense die Methode PrintToConsole vor. Dies ist die neue Methode, die zum Typ string hinzugefügt wurde.

Wie der Methodenaufruf funktioniert (6:30)

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

• Demo ist ein Stringtyp: Die Variable demo ist vom Typ string.
• Erweiterter Stringtyp: 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 - die Zeichenkette demo 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)

Ausführen des Codes (7:08)

Schließlich, wenn die Methode PrintToConsole aufgerufen wird, gibt sie die Zeichenkette auf die Konsole aus:

Console.WriteLine(message);

Console.WriteLine(message);

Also druckt der Aufruf von demo.PrintToConsole() "This is a demo" auf die Konsole.

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 werfen wir einen Blick auf die Klasse SimpleLogger um 11:09.

Hier verwendet Tim die hypothetische Drittanbieterklasse SimpleLogger, die Nachrichten in die 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}");
    }
}

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

Aufrufe konsistenter gestalten

Mit ihr in der Hand ist er jetzt um 14:02 in der Lage, die Erweiterungsmethoden auf eine Instanz von SimpleLogger aufzurufen:

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

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

Vergleich mit direkten Methodenaufrufen (17:21)

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

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
}

Jetzt können Sie diese Methoden verketten:

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

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 Klasse Person, ohne Datenbanklogik einzubetten.

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.