C# Academy · Lezione

Definizione dei metodi di estensione

Scriva metodi statici con il modificatore this.

Definizione dei metodi di estensione è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Che cos'è un metodo di estensione

Un metodo di estensione consente di aggiungere nuovi metodi a un tipo esistente senza modificarlo né creare un tipo derivato. Lo si chiama come se fosse un metodo di istanza, ma in realtà è uno speciale metodo static.

I metodi di estensione sono perfetti quando non si possiede il codice sorgente di un tipo, come string o int, ma si desidera aggiungervi un nuovo comportamento pratico.

I tre requisiti

Per dichiarare un metodo di estensione occorrono: una classe statica, un metodo statico e un primo parametro contrassegnato dalla parola chiave this. Il parametro this indica il tipo che si sta estendendo.

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

Chiamarlo come un metodo di istanza

Anche se WordCount è statico, lo si chiama come sentence.WordCount(). Il compilatore riscrive internamente questa chiamata come StringExtensions.WordCount(sentence).

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

Il parametro this riceve l'istanza

Il valore a sinistra del punto diventa il parametro this. Dopo di esso è possibile aggiungere altri parametri, che i chiamanti passano normalmente.

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

Estendere i propri tipi

I metodi di estensione non servono solo per i tipi delle librerie. È possibile estendere anche le proprie classi, mantenendo così pulito il tipo principale e aggiungendo altrove i comportamenti di supporto.

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

I metodi di estensione non possono accedere ai membri private

Un metodo di estensione è semplicemente un metodo statico in un'altra classe, quindi può usare solo la superficie public (o internal, quando si trova nello stesso assembly) del tipo. Non può accedere ai campi private.

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

Concatenare i metodi di estensione

Poiché ogni metodo di estensione restituisce un valore, è possibile concatenarli in una pipeline fluente. Il codice si legge dall'alto verso il basso: è lo stile usato da 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 e metodi di estensione

A differenza di una vera chiamata a un'istanza, un metodo di estensione può essere eseguito anche quando il ricevitore è null, perché non viene dereferenziato nulla finché il codice non vi accede. Questo consente di scrivere helper sicuri rispetto 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());
    }
}

I metodi di istanza hanno la precedenza sui metodi di estensione

Se esiste un vero metodo di istanza con una firma corrispondente, il compilatore lo preferisce sempre a un metodo di estensione. Le estensioni colmano solo le lacune non già coperte dal tipo.

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 libreria pratica di helper

Raggruppare le estensioni correlate in un'unica classe statica crea una libreria di utility ordinata. Ecco una piccola classe di helper numerici che è possibile riutilizzare in un progetto.

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

Provi a farlo autonomamente

Metta insieme ciò che ha imparato: una classe statica con diverse estensioni mirate, chiamate con sintassi fluente. È esattamente il modo in cui vengono create le librerie di helper di uso quotidiano.

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('*'));
    }
}

Verifica rapida

Verifichi la comprensione della dichiarazione dei metodi di estensione.

Riepilogo

Ha imparato che un metodo di estensione è un metodo static in una classe static il cui primo parametro utilizza this. Viene chiamato con la sintassi di istanza, ma compilato come una normale chiamata statica.

Tre requisiti: classe statica, metodo statico, primo parametro this.
Sono accessibili solo i membri public.
I metodi di istanza hanno sempre la precedenza.
Le estensioni possono essere concatenate e possono persino essere eseguite su ricevitori null.

Domande Frequenti

La lezione «Definizione dei metodi di estensione» è gratuita?

Sì — il testo completo di «Definizione dei metodi di estensione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Definizione dei metodi di estensione»?

Scriva metodi statici con il modificatore this. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Definizione dei metodi di estensione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy