Nel mondo java, è chiamato Runnable . Nel mondo C #, si chiama Action .
Ma c'è un nome migliore che si adatta bene a una visione più ampia delle cose.
La visione più ampia delle cose viene dopo, quando decidi che oltre all'interfaccia funzionale priva di parametri devi anche avere interfacce funzionali simili che accettano uno, due o più argomenti o che restituiscono un valore. Quando ciò accade, vorrai che i nomi di tutte quelle entità siano isomorfe e corrispondenti l'uno con l'altro.
Quindi, in Java, ho il mio insieme di interfacce funzionali che chiamo Procedure s, definito come segue:
public interface Procedure
{
void invoke();
}
public interface Procedure1<T1>
{
void invoke( T1 argument1 );
}
... (ottieni l'immagine.)
E ho anche un insieme simile di interfacce chiamate Function s, definite in modo simile, con il primo parametro generico che è il tipo di ritorno:
public interface Function<R>
{
R invoke();
}
public interface Function1<R,T1>
{
R invoke( T1 argument1 );
}
Quindi, il mio punto qui è che Procedure è un nome molto buono perché si adatta perfettamente a una visione più ampia delle cose. Se in un secondo momento decidi di avere interfacce funzionali simili con metodi che accettano argomenti o restituiscono un valore, ti imbatterai in questo.
NOTA: fondamentalmente sono d'accordo con l'affermazione di Karl Bielefeldt che "i normali principi di denominazione dovrebbero [non] uscire dalla finestra "e che" Le interfacce dovrebbero quasi sempre essere intitolate a quello che fanno, non dopo un'idea generica sintattica ". Ma nota che anche lui ammette "quasi sempre". A volte c'è bisogno di procedure e funzioni (essenzialmente anonime), ed è quello che l'OP sta chiedendo, ed è quello che sto rispondendo.
Modifica 2017-11-10:
Potresti chiedere perché Function1<R,T1> anziché Function1<T1,R> ? Potrebbe andare in entrambi i modi, ma ho una preferenza per i valori di ritorno a sinistra perché mi piace seguire la convenzione di denominazione 'convert-from' (destinazione-da-sorgente) in opposizione al 'convert-to' (source-to -destinazione) convenzione. (Che è più un incidente che una convenzione, in realtà, nel senso che molto probabilmente nessuno ci ha mai pensato, perché se gli avessero dato qualche pensiero sarebbero arrivati alla convention "convert-da". )
Ho letto di questo in Joel Spolksy - Rendere il codice sbagliato apparire sbagliato , è un articolo molto lungo, che consiglio di leggere nella sua interezza, ma se vuoi saltare direttamente al caso, cerca 'TypeFromType', ma per darti il TL; DR, l'idea è che myint = intFromStr( mystr ) è molto meglio di myint = strToInt( mystr ) , perché nel primo caso i nomi dei tipi sono vicini ai valori associati, quindi puoi facilmente vedere che "int" corrisponde a "int" e "str" corrisponde con lo "str".
Quindi, per estensione, tendo a ordinare le cose nel modo in cui appariranno nel codice.