Comprender los métodos y utilizar los métodos de extensión de C#

Métodos de instancia definidos

En C#, un método se define dentro de una clase. La sintaxis general de una definición de método incluye un modificador de acceso, el tipo de retorno, el nombre del método y los parámetros.

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

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

En el ejemplo de Tim Corey del minuto 4:05, define un método dentro de una clase estática para crear un método de extensión. El método definido es PrintToConsole. La definición incluye toda la sintaxis general que explica claramente cómo definir un método con un ejemplo práctico:

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

Cómo llamar a un método

Una "llamada a método" indica al programa que ejecute un método específico definido en otra parte del código, realizando una acción predefinida. Los métodos se llaman utilizando la instancia de la clase, o directamente si son métodos estáticos. En el caso de los métodos de extensión, aparecen como si formaran parte del tipo que extienden. En el vídeo del minuto 6:18, Tim muestra cómo llamar a un método de extensión con un tipo de datos primitivo al igual que sus métodos predefinidos.

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

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

Parámetros

Los parámetros se especifican en la definición del método y actúan como marcadores de posición para los valores que se pasan al método. Puedes verlo aquí después de que se llame al método WriteLine, donde message es el parámetro.

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

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

De nuevo, en el ejemplo del método de extensión que dio Tim Corey a las 4:05, message es el parámetro:

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

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

Argumentos

Los argumentos son los valores reales que se pasan al método cuando se invoca.

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

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

Cuando Tim Corey llama al método a las 6:20 usando la sintaxis de punto con el tipo de cadena, el valor de la cadena en realidad se está pasando como un valor al método PrintToConsole:

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

¿Qué son los métodos de extensión? (3:13)

Los métodos de extensión permiten añadir nuevos métodos a tipos existentes sin tener que modificarlos o recompilarlos. Aunque se denominan como si fueran métodos de instancia, los métodos de extensión se definen como estáticos.

Creación de un método de extensión

En la sección anterior, "Definición y llamada a métodos", destacamos cómo Tim Corey creó un método de extensión en una clase estática independiente y definió el método estático dentro de ella para utilizarlo como método de extensión. Estos son algunos de los puntos clave en los que hace hincapié Tim Corey:

1. Asegúrate de definir una clase estática pública separada o, como dice Tim, "marca la clase como estática, de lo contrario no funcionará"
2. A medida que cree más métodos de extensión, agrúpelos por tipo (3:43)
3. Define un método estático con el primer parámetro precedido por la palabra clave this, especificando el tipo a extender (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);
    }
}

Llamando al método de extensión (6:18)

A continuación, Tim muestra cómo llamar a un método de extensión en esta variable de cadena:

demo.PrintToConsole();

demo.PrintToConsole();

Cuando introduces demo y comienzas a escribir Print, IntelliSense sugiere el método PrintToConsole. Este es el nuevo método añadido al tipo string.

Cómo funciona la llamada al método (6:30)

Tim explica por qué puedes llamar a demo.PrintToConsole():

• Demo es un tipo de cadena: La variable demo es de tipo string.
• Tipo de cadena extendido: El tipo string ha sido extendido con el nuevo método PrintToConsole.

Entendiendo el parámetro (6:41)

Aunque parece que no se están pasando parámetros al método PrintToConsole, Tim señala el paso implícito de parámetros: la cadena demo se pasa como el primer parámetro al método de extensión.

Tim hace hincapié en que los métodos de extensión tienen un parámetro menos en la llamada que en su definición. Esto se debe a que el primer parámetro (el tipo que se amplía) está implícito.

Firma del método de extensión

Aquí, this string message significa que el método extiende el tipo string, y message es el parámetro implícito:

public static void PrintToConsole(this string message)

public static void PrintToConsole(this string message)

Ejecutando el código (7:08)

Finalmente, cuando se llama al método PrintToConsole, imprime la cadena en la consola:

Console.WriteLine(message);

Console.WriteLine(message);

Así que, llamar a demo.PrintToConsole() imprime "This is a demo" en la consola.

Ampliación de clases de terceros (10:59)

Tim Corey explica que los métodos de extensión pueden extender cualquier tipo, incluso clases de terceros que no se pueden modificar directamente. Por ejemplo, echemos un vistazo a la clase SimpleLogger a las 11:09.

Aquí, Tim utiliza la clase hipotética de terceros SimpleLogger que registra mensajes en la consola (11:09). La clase tiene dos métodos:

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

Estos métodos no son ideales porque el tipo de mensaje es una cadena simple, lo que puede dar lugar a incoherencias. Tim sugiere crear métodos de extensión para mejorar la clase.

Implementación de tipos de mensajes coherentes

El uso de métodos de extensión garantiza la coherencia del código al utilizar siempre los mismos tipos de mensajes y el mismo formato. Aquí, a las (12:40), Tim crea una clase estática 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");
    }
}

Hacer llamadas más coherentes

Con ella en mano, a las (14:02) ahora puede llamar a los métodos de extensión en una instancia SimpleLogger:

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

Esto garantiza que los tipos de mensaje sean siempre "Error" y "Advertencia".

Mejora del formato de salida (14:35)

Tim añade la funcionalidad de establecer el color del texto de la consola para los mensajes de error, asegurándose de que destaquen:

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

Comparación con las llamadas directas a métodos (17:21)

Tim compara este enfoque con llamar directamente a los métodos originales Log, lo que podría causar inconsistencias:

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

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

Este enfoque es propenso a errores tipográficos y formatos incoherentes.

Métodos de extensión de encadenamiento (18:13)

Tim demuestra cómo se pueden encadenar los métodos de extensión para que el código sea más legible:

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
}

Ahora, puedes encadenar estos métodos:

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

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

Esto hace que el código sea más legible e intuitivo en comparación con las llamadas a métodos anidados:

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

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

Al utilizar la notación por puntos y el encadenamiento, la intención del código es más clara y está menos anidada.

Ampliar cosas que no se poseen

En el minuto 20:13, Tim Corey explica que los métodos de extensión son ideales para añadir funcionalidad a clases que no son de tu propiedad, como bibliotecas de terceros. Esto permite realizar mejoras sin modificar el código original.

Evitar dependencias

Corey también destaca el uso de métodos de extensión para introducir dependencias sin acoplarlas directamente a una clase. Por ejemplo, agregar funcionalidad de guardado en base de datos a una clase Person sin incrustar lógica de base de datos.

Ampliación de interfaces

Los métodos de extensión también pueden aplicarse a interfaces, como se explica a partir del minuto 21:30, lo que permite que varias clases que implementan la interfaz compartan la misma funcionalidad. Esto promueve la reutilización y simplificación del código.

Cuándo no usar métodos de extensión

En el minuto 23:03, Tim Corey desaconseja el uso excesivo de métodos de extensión, especialmente con tipos primitivos o proporcionados por Microsoft, para evitar el desorden y la complejidad. Utilícelas con moderación y solo cuando ofrezcan ventajas claras.

El principio abierto/cerrado

En la sección entre 24:54-25:40, Tim hace hincapié en la adhesión al principio abierto/cerrado mediante el uso de métodos de extensión para añadir nuevas funcionalidades sin modificar el código estable existente, reduciendo así el riesgo de introducir errores.

Bestes prácticas para el uso de sentencias

Organice los métodos de extensión agrupándolos de forma lógica y colocándolos en espacios de nombres separados para evitar conflictos de nomenclatura y facilitar el mantenimiento y la depuración.