0Pricing
C# Academy · Lección

Definición de métodos de extensión

Escriba métodos estáticos con el modificador this.

Definición de métodos de extensión es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

¿Qué es un método de extensión?

Un método de extensión permite añadir métodos a un tipo existente sin modificarlo ni crear un tipo derivado. Se invoca como si fuera un método de instancia, pero en realidad es un método static especial.

Las extensiones son perfectas cuando no posee el código fuente de un tipo (como string o int), pero quiere dotarlo de un comportamiento nuevo y práctico.

Los tres requisitos

Para declarar un método de extensión necesita: una clase estática, un método estático y un primer parámetro marcado con la palabra clave this. El parámetro this indica el tipo que está extendiendo.

using System;

public static class StringExtensions
{
    public static int WordCount(this string text)
    {
        if (string.IsNullOrWhiteSpace(text)) return 0;
        return text.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}

public class Program
{
    public static void Main()
    {
        string sentence = "the quick brown fox";
        Console.WriteLine(sentence.WordCount());
    }
}

Invocarlo como un método de instancia

Aunque WordCount es estático, se invoca como sentence.WordCount(). El compilador reescribe esa llamada como StringExtensions.WordCount(sentence) internamente.

using System;
using System.Linq;

public static class StringExtensions
{
    public static string Repeat(this string text, int times)
    {
        return string.Concat(Enumerable.Repeat(text, times));
    }
}

public class Program
{
    public static void Main()
    {
        // These two lines do exactly the same thing
        Console.WriteLine("ab".Repeat(3));
        Console.WriteLine(StringExtensions.Repeat("ab", 3));
    }
}

El parámetro this recibe la instancia

El valor situado a la izquierda del punto se convierte en el parámetro this. Puede añadir más parámetros después de este, y los llamadores los pasan de la forma habitual.

using System;

public static class IntExtensions
{
    public static bool IsBetween(this int value, int low, int high)
    {
        return value >= low && value <= high;
    }
}

public class Program
{
    public static void Main()
    {
        int age = 25;
        Console.WriteLine(age.IsBetween(18, 65));
        Console.WriteLine(10.IsBetween(1, 5));
    }
}

Extender sus propios tipos

Las extensiones no son solo para tipos de biblioteca. También puede extender sus propias clases, lo que resulta útil para mantener limpio el tipo principal y añadir comportamientos auxiliares en otro lugar.

using System;

public class Money
{
    public decimal Amount { get; }
    public Money(decimal amount) { Amount = amount; }
}

public static class MoneyExtensions
{
    public static string ToUsd(this Money m) => "$" + m.Amount.ToString("0.00");
}

public class Program
{
    public static void Main()
    {
        var price = new Money(19.5m);
        Console.WriteLine(price.ToUsd());
    }
}

Las extensiones no pueden acceder a miembros privados

Un método de extensión es simplemente un método estático de otra clase, por lo que solo puede utilizar la superficie pública (o interna, cuando se encuentra en el mismo ensamblado) del tipo. No puede acceder a sus campos privados.

using System;

public class Counter
{
    private int _count;
    public int Value => _count;
    public void Increment() => _count++;
}

public static class CounterExtensions
{
    // Can only use public members like Value and Increment
    public static bool IsZero(this Counter c) => c.Value == 0;
}

public class Program
{
    public static void Main()
    {
        var c = new Counter();
        Console.WriteLine(c.IsZero());
        c.Increment();
        Console.WriteLine(c.IsZero());
    }
}

Encadenar métodos de extensión

Como cada extensión devuelve un valor, puede encadenarlas en una canalización fluida. Este estilo se lee de arriba abajo y es el que utiliza LINQ.

using System;

public static class TextExtensions
{
    public static string Shout(this string s) => s.ToUpper();
    public static string Bang(this string s) => s + "!";
}

public class Program
{
    public static void Main()
    {
        string result = "hello".Shout().Bang();
        Console.WriteLine(result);
    }
}

null y los métodos de extensión

A diferencia de una llamada de instancia real, un método de extensión puede ejecutarse incluso cuando el receptor es null, porque no se desreferencia nada hasta que el código accede a él. Esto permite escribir utilidades seguras frente a null.

using System;

public static class StringExtensions
{
    public static bool IsBlank(this string text)
    {
        // text may be null here, and that is fine
        return string.IsNullOrWhiteSpace(text);
    }
}

public class Program
{
    public static void Main()
    {
        string nothing = null;
        Console.WriteLine(nothing.IsBlank());
        Console.WriteLine("x".IsBlank());
    }
}

Los métodos de instancia tienen prioridad sobre las extensiones

Si existe un método de instancia real con una firma coincidente, el compilador siempre lo prefiere a un método de extensión. Las extensiones solo cubren los casos que el tipo todavía no admite.

using System;

public static class Ext
{
    // This will be ignored because string already has ToString()
    public static string ToString(this string s, int n) => s + n;
}

public class Program
{
    public static void Main()
    {
        // Resolves to the built-in instance ToString(), not the extension
        Console.WriteLine("value: " + "abc".ToString());
    }
}

Una biblioteca práctica de utilidades

Agrupar extensiones relacionadas en una sola clase estática crea una biblioteca de utilidades ordenada. Esta es una pequeña clase de utilidades numéricas que podría reutilizar en todo un proyecto.

using System;

public static class NumberExtensions
{
    public static bool IsEven(this int n) => n % 2 == 0;
    public static int Squared(this int n) => n * n;
    public static double Percent(this int n) => n / 100.0;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(4.IsEven());
        Console.WriteLine(5.Squared());
        Console.WriteLine(50.Percent());
    }
}

Pruébelo usted mismo

Combine lo aprendido: una clase estática con varias extensiones específicas, invocadas de forma fluida. Así es exactamente como se crean las bibliotecas de utilidades de uso cotidiano.

using System;

public static class StringExtensions
{
    public static string Capitalize(this string s)
        => string.IsNullOrEmpty(s) ? s : char.ToUpper(s[0]) + s.Substring(1);
    public static string Surround(this string s, char c) => c + s + c;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("hello".Capitalize().Surround('*'));
    }
}

Comprobación rápida

Compruebe su comprensión de la declaración de métodos de extensión.

Resumen

Ha aprendido que un método de extensión es un método static de una clase static cuyo primer parámetro utiliza this. Se invoca con la sintaxis de una instancia, pero se compila como una llamada estática normal.

  • Tres requisitos: clase estática, método estático y primer parámetro this.
  • Solo se puede acceder a miembros públicos.
  • Los métodos de instancia siempre tienen prioridad.
  • Las extensiones se pueden encadenar e incluso pueden ejecutarse sobre receptores null.

Preguntas frecuentes

¿La lección «Definición de métodos de extensión» es gratis?

Sí — el texto completo de «Definición de métodos de extensión» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Definición de métodos de extensión»?

Escriba métodos estáticos con el modificador this. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Definición de métodos de extensión»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Definición de métodos de extensión
  2. Extensión de interfaces y genéricos
  3. Resolución de métodos de extensión
  4. Diseño de buenas extensiones
← Volver a C# Academy