Quanto sono veloci le reflection

La reflection permette al codice di poter istanziare classi o chiamare metodi privati senza passare per la classe stessa; capire quanto queste siano veloci permette di scrivere codice più performante.

E’ possibile utilizzare le reflection per creare una istanza di un oggetto di un determinato tipo, per chiamare dei metodi non public, per accedere ai suoi campi privati.

L’obiettivo di questo articolo è capire quanto è lenta la reflection rispetto all’utilizzo di un metodo normale e cose è possibile fare per ottimizzarla il più possibile.

Per effettuare questa misurazione utilizzeremo il mitico pacchetto benchmarkDotNet.

Consideriamo la seguente classe Furniture con una property Color {get; private set;} e un metodo SetColor per andare ad impostarne il colore.

public class Furniture
{
    public string Color { get; private set; }
 
    public void SetColor(string color)
    {
        Color = color;
    }
    
    private void SetColorPrivate(string color)
    {
        Color = color;
    }
}

Andiamo ad impostare ora la property Color utilizzando vari metodi, per poi misurarne le performance.

Non Reflection

In questo caso andiamo a impostare il colore usando il metodo SetColor.

[Benchmark]
public void NonReflection()
{
    _furniture.SetColor("Foo");
}

Reflection senza cache

Il metodo più semplice per impostare una property privata è usare il metodo SetValue di una PropertyInfo ottenuta dal metodo GetProperty.

[Benchmark]
public void ReflectionNonCached()
{
    typeof(Furniture).GetProperty("Color")?.SetValue(_furniture, "Foo");
}

Reflection con cache

Un miglioramento del metodo precedente è calcolare una sola volta la PropertyInfo nel seguente modo.

private static readonly PropertyInfo ColorPropertyInfo = typeof(Furniture).GetProperty("Color")!;
 
[Benchmark]
public void ReflectionCached()
{
    ColorPropertyInfo.SetValue(_furniture, "Foo");
}

Reflection su backing field

Le property vengono tradotte da .NET in due metodi che puntano ad un backing field. Per dimostrare questo apriamo Sharplab e incolliamo la classe Furniture. Otteniamo il seguente codice:

public class Furniture
{
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string <Color>k__BackingField;
 
    public string Color
    {
        [CompilerGenerated]
        get
        {
            return <Color>k__BackingField;
        }
        [CompilerGenerated]
        private set
        {
            <Color>k__BackingField = value;
        }
    }
 
    public void SetColor(string color)
    {
        Color = color;
    }
}

Vediamo infatti la presenza di un campo chiamato <Color>k__BackingField. Possiamo sfruttare questa informazione per modificare quel campo tramite reflection, scrivendo quindi:

private static readonly FieldInfo CachedField =
typeof(Furniture).GetField("<Color>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic)!;
 
[Benchmark]
public void ReflectionCachedWothField()
{
    CachedField.SetValue(_furniture, "Foo");
}

Reflection con delegate

Infine sfruttiamo il metodo GetSetMethod di PropertyInfo: questo metodo permette di andare a prendere un puntatore a funzione del metodo set di una property, anche se questo è privato.

Questo puntatore viene convertito in Delegate e castato come Action in modo da poter essere chiamato.

Il codice per ottenere ciò è il seguente:

private static readonly Action<Furniture, string> SetColorDelegate =
(Action<Furniture, string>)Delegate.CreateDelegate(typeof(Action<Furniture, string>), ColorPropertyInfo.GetSetMethod(true)!);
 
[Benchmark]
public void ReflectionWithDelegate()
{
    SetColorDelegate(_furniture, "Foo");
}

Reflection con metodo privato

Come ultimo test proviamo a modificare la property chiamando un metodo privato (SetColorPrivate) nella classe.

private static readonly Action<Furniture, string> SetColorPrivateDelegate =
(Action<Furniture, string>)Delegate.CreateDelegate(typeof(Action<Furniture, string>), SetColorPrivateMethodInfo);
 
[Benchmark]
public void ReflectionMethodWithDelegate()
{
    SetColorPrivateDelegate(_furniture, "Foo");
}

Risultati

Dopo aver descritto tutti i metodi con cui è possibile modificare un campo privato di una classe andiamo a vedere i risultati.

Method	Mean	Error	StdDev
NonReflection	2.321 ns	0.1104 ns	0.2445 ns
ReflectionNonCached	254.680 ns	8.7334 ns	23.7599 ns
ReflectionCached	168.553 ns	4.8918 ns	13.7973 ns
ReflectionCachedWithField	85.107 ns	1.9745 ns	5.5690 ns
ReflectionWithDelegate	5.944 ns	0.3231 ns	0.9425 ns
ReflectionMethodWithDelegate	5.970 ns	0.4275 ns	1.2334 ns

Ovviamente il metodo più veloce è quello senza reflection, ma quanto posso andarci vicino?

Utilizzare una cache della PropertyInfo sicuramente aiuta, come si vede dalla differenza tra i benchmark ReflectionNonCached e ReflectionCached.

Un ulteriore miglioramento è puntare al backing field privato <Color>k__BackingField.

Il vero boost di prestazioni si ha utilizzando il puntatore a funzione del metodo set, con un miglioramento di circa 25x rispetto al metodo che punta al backing field e di 55x rispetto al metodo più lento.

Puntare ad un metodo privato ha delle performance praticamente uguali a quelle di puntare al metodo set, come è intuitivo che sia, dato che, di fatto, sono la stessa cosa.

Conclusioni

Le reflection in .NET sono estremamente veloci, utilizzando i giusti accorgimenti hanno quasi le performance di chiamare un metodo in modo classico.

Il loro problema non è quindi la velocità ma semmai la manutenibilità e l’estendibilità del codice: questo infatti risulta più difficile da leggere, gli errori vengono rilevati solo runtime e, in generale, le reflection permettono di violare tutte le regole di buona programmazione.