0Pricing
C# Academy · Lezione

Funzioni locali statiche

Eviti le catture per migliorare chiarezza e prestazioni.

Funzioni locali statiche è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Funzioni locali static

Contrassegnare una funzione locale con static le impedisce di catturare variabili dell'ambito che la contiene o this. In questo modo la funzione è autonoma, più chiara e non crea allocazioni nascoste per una closure.

Dichiarare una funzione locale static

Aggiunga il modificatore static prima del tipo restituito. La funzione può comunque accettare parametri e restituire valori; semplicemente non può accedere alle variabili locali esterne.

using System;

public class Program
{
    public static void Main()
    {
        static int Square(int n) => n * n; // captures nothing

        Console.WriteLine(Square(6));
    }
}

Nessuna cattura consentita

Una funzione locale static non può usare le variabili locali dell'ambito che la contiene. Tutto ciò che le serve deve essere passato come parametro, rendendo espliciti i suoi input.

using System;

public class Program
{
    public static void Main()
    {
        int factor = 3;
        // factor must be passed in, not captured
        static int Scale(int n, int f) => n * f;

        Console.WriteLine(Scale(5, factor));
    }
}

Evitare allocazioni nascoste

Le funzioni locali non static che catturano variabili possono allocare un oggetto closure nascosto. Una funzione locale static non cattura nulla, quindi evita completamente tale allocazione.

using System;

public class Program
{
    public static void Main()
    {
        // Pure helper, no closure object created
        static bool IsEven(int n) => n % 2 == 0;

        for (int i = 0; i < 5; i++)
            Console.WriteLine(i + ": " + IsEven(i));
    }
}

Intento autoesplicativo

La parola chiave static segnala ai lettori che l'helper dipende solo dai propri argomenti. Questa garanzia rende la funzione più facile da comprendere e testare.

using System;

public class Program
{
    public static void Main()
    {
        static int Clamp(int value, int lo, int hi)
            => value < lo ? lo : value > hi ? hi : value;

        Console.WriteLine(Clamp(15, 0, 10));
        Console.WriteLine(Clamp(-3, 0, 10));
    }
}

Il compilatore impone l'assenza di catture

Se fa accidentalmente riferimento a una variabile locale dell'ambito che la contiene all'interno di una funzione locale static, il compilatore segnala un errore. In questo modo le dipendenze indesiderate vengono rilevate tempestivamente.

using System;

public class Program
{
    public static void Main()
    {
        int seed = 7;
        // Correct: seed is passed explicitly, not captured
        static int Mix(int x, int s) => x * 31 + s;

        Console.WriteLine(Mix(2, seed));
    }
}

Funzioni locali static con ricorsione

Le funzioni locali static supportano comunque la ricorsione, perché chiamare sé stesse non equivale a catturare una variabile.

using System;

public class Program
{
    public static void Main()
    {
        static int Power(int baseN, int exp)
            => exp == 0 ? 1 : baseN * Power(baseN, exp - 1);

        Console.WriteLine(Power(2, 10));
    }
}

Combinare con i parametri out

Come qualsiasi metodo, le funzioni locali static possono usare parametri out, una caratteristica che si abbina bene alla loro purezza e assenza di catture per gli helper in stile try-parse.

using System;

public class Program
{
    public static void Main()
    {
        static bool TryParsePositive(string s, out int value)
        {
            value = 0;
            return int.TryParse(s, out value) && value > 0;
        }

        if (TryParsePositive("42", out int n))
            Console.WriteLine("got " + n);
        Console.WriteLine(TryParsePositive("-1", out _));
    }
}

Passare funzioni locali static come delegati

Poiché non catturano nulla, le funzioni locali static si convertono in delegati senza allocare una closure, cosa che può essere importante nei percorsi più eseguiti.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        static bool IsBig(int n) => n > 100;

        var nums = new List<int> { 50, 150, 200, 10 };
        Console.WriteLine(nums.Count(IsBig));
    }
}

Quando preferire static

Preferisca una funzione locale static ogni volta che l'helper non necessita dello stato dell'ambito che lo contiene. In questo modo documenta la purezza, impedisce catture accidentali e può risultare più efficiente. Rimuova static solo quando ha realmente bisogno di catturare variabili locali.

using System;

public class Program
{
    public static void Main()
    {
        static string Describe(int score)
        {
            if (score >= 90) return "A";
            if (score >= 80) return "B";
            return "C";
        }

        Console.WriteLine(Describe(95));
        Console.WriteLine(Describe(82));
    }
}

Provi autonomamente

Scriva una funzione locale static pura e la passi come predicato a LINQ. Poiché non cattura nulla, si converte in un delegato senza una closure.

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        static bool IsLeapYear(int year)
            => (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;

        var years = new List<int> { 1900, 2000, 2004, 2021, 2024 };
        Console.WriteLine(string.Join(", ", years.Where(IsLeapYear)));
    }
}

Controllo rapido

Richiami alla memoria cosa aggiunge static a una funzione locale.

Riepilogo

Una funzione locale static non cattura nulla.

  • Non può usare le variabili locali dell'ambito che la contiene né this; passi i dati tramite parametri.
  • Evita le allocazioni nascoste delle closure.
  • Il compilatore impone la regola di assenza di catture, rilevando le dipendenze accidentali.
  • La preferisca quando l'helper non necessita dello stato dell'ambito che lo contiene.

Domande Frequenti

La lezione «Funzioni locali statiche» è gratuita?

Sì — il testo completo di «Funzioni locali statiche» è 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 «Funzioni locali statiche»?

Eviti le catture per migliorare chiarezza e prestazioni. 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 3 di 4.

Quanto tempo richiede la lezione «Funzioni locali statiche»?

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

  1. Dichiarazione delle funzioni locali
  2. Closure e variabili catturate
  3. Funzioni locali statiche
  4. Funzioni locali e lambda a confronto
← Torna a C# Academy