IRONSOFTWAREHOME
IRONSUITETodos los 10 por el precio de 2
EDICIÓN DE DOCUMENTOS
IMAGEN Y RECONOCIMIENTO
RECURSOS DE ADQUISICIÓN
CONTACTAR VENTAS
POR EMPRESA
HERRAMIENTAS GRATUITAS
ÚNETE A NUESTRA RED DE EXPERTOS

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

Comprendiendo las variables y los tipos de datos de C#

Tim Corey

28m 27s

En la programación en C#, los métodos son bloques de construcción esenciales que encapsulan código reutilizable y realizan tareas específicas. Pueden aceptar parámetros, devolver valores y sobrecargarse para manejar entradas variables. Los métodos de extensión, un concepto más avanzado, permiten a los desarrolladores añadir funcionalidad a tipos existentes, incluidos aquellos que no controlan.

El vídeo de Tim Corey ‘Cómo crear métodos de extensión en C#’ es un recurso excelente. En esta guía, exploraremos varios temas que cubre Tim:

  1. Definición y llamada a métodos
  2. Parámetros y argumentos de los métodos
  3. Valores de retorno de los métodos
  4. Sobrecarga de métodos
  5. Implementación de métodos de extensión

Definición y llamada a métodos

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

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

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

Parámetros y argumentos de los métodos

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

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

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

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

Valores de retorno de los métodos

Los métodos pueden devolver valores mediante la sentencia return. El tipo de retorno se especifica en la firma del método.

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

Aunque el método de extensión del vídeo de Tim Corey no devuelve ningún valor (tipo de retorno void), se pueden crear métodos de extensión con valores de retorno. El tipo de retorno en el ejemplo de Tim es void, lo que significa que el método no devuelve ningún valor. El siguiente ejemplo muestra cómo devolver un valor:

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

Sobrecarga de métodos (11:15)

La sobrecarga de métodos permite que varios métodos tengan el mismo nombre pero parámetros diferentes. Esto puede ser útil para crear API flexibles e intuitivas.

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

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

Tim Corey aborda brevemente la creación de múltiples métodos para diferentes escenarios de registro en el minuto 11:24, lo que puede considerarse un ejemplo de sobrecarga de métodos en un sentido más amplio. El método log existe dos veces, una con un parámetro y otra con dos parámetros. El segundo método log a las 11:39 es la versión sobrecargada del método log, lo que le confiere múltiples funcionalidades bajo el mismo nombre.

Implementing Extension Methods in C#

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

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

Cuando ingresas 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 del tipo string.
  • Tipo de Cadena Extendida: 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 la pasada implícita 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)

Ejecutando el código (7:08)

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

Console.WriteLine(message);

Así, llamar a demo.PrintToConsole() imprime "Esto es una demostración" en la consola.

Uso de métodos de extensión para clases de terceros

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

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

Hacer llamadas más coherentes

Con esto en mano, (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");

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

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 llevar a inconsistencias:

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
}

Ahora, puedes encadenar estos métodos:

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

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, añadir funcionalidad de guardar 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.

Conclusión

Y ahí lo tienes, ahora entiendes lo básico de definir y llamar métodos, manejar parámetros y valores de retorno, y aprovechar la sobrecarga de métodos. Con ello, podrá crear aplicaciones robustas y flexibles en C#.

Los métodos de extensión, tal y como los explica Tim Corey, ofrecen una forma eficaz de mejorar los tipos existentes y hacer que el código sea más legible y fácil de mantener. Para obtener información más detallada y ejemplos prácticos, puede ver el vídeo completo de Tim Corey sobre Cómo crear métodos de extensión en 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

Key in blue circle

Obtenga su clave de prueba gratuita de 30 días al instante.

Your trial license will be sent to your email address

Sin limitaciones. 100 % desbloqueado. Sin tarjeta de crédito.

bullet_checkedNo se requiere tarjeta de crédito ni creación de cuentaSin limitaciones. 100 % desbloqueado. Sin tarjeta de crédito.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronPDF
Obtén tu Consulta Sin Compromiso
Completa el formulario a continuación o envía un correo a sales@ironsoftware.com
Tus detalles siempre serán mantenidos confidenciales.
Confiado por millones de ingenieros en todo el mundo
Logos de clientes de Iron Software
Obtenga su Clave de Prueba de 30 días gratis al instante.
No se requiere tarjeta de crédito ni creación de cuenta