Scrivere metodi di estensione con Action / Func / Delegates / Lambda in VB e C #

Question

In primo luogo non riesco a capire meglio gli aspetti funzionali / lambda di .NET 3.5. Uso queste funzionalità ogni giorno in LINQ, ma il mio problema è capire l'implementazione e cosa significano realmente (Lambda? System.Func? Etc etc)

Tenendo presente ciò, come si otterrebbe quanto segue:

Ad esempio, vorrei avere un metodo Extension per List (Of T) che imposta le proprietà di tutti gli oggetti dell'Elenco su un determinato valore e restituisce l'Elenco aggiornato (Of T). Si chiamerebbe così:

VB:

 Dim someList As List(Of TextBox) =  (New List(Of TextBox)).UpdateExtension(Function(txtb) txtb.Text = "something")

C #:

List<TextBox> someList = (new List<TextBox>()).UpdateExtension(txtb => txtb.Text = "something");

Che aspetto avrebbe il metodo Extension, sia in VB che in C #?

cioè:

 <Extension()> _
 Public Function UpdateExtension(Of T)(ByVal source As List(Of T), ByVal predicate As ??) As List(Of T)
        '??
 End Function

evviva!

Modifica

Come molti hanno sottolineato, quanto sopra può essere ottenuto, più o meno, con .ForEach (). Ma il mio interesse è quello di sottolineare come viene implementato qualcosa come .ForEach (), ovvero sono interessato all'implementazione della soluzione per il problema di cui sopra.

Answer 1

Davvero stai facendo il miking e abbinando i metodi di estensione qui. È quasi una combinazione di Select e ForEach. Sembra che tu voglia un metodo che ti permetta sia di modificare gli elementi di un elenco sia di restituire l'enumerazione originale. Quanto segue dovrebbe fare il trucco per te.

VB.Net

<Extension()> _
Public Function UpdateExtension(Of T)(ByVal source As IEnumerable(Of T), ByVal del As Action(Of T)) As IEnumerable(Of T)
  For Each cur in source
    del(cur)
  Next
  Return source
End Function

C #

public static IEnumerable<T> UpdateExtension<T>(this IEnumerable<T> source, Action<T> del) {
  foreach ( var cur in source ) {
    del(cur);
  }
  return source;
}

Answer 2

Con l'eccezione di modificare l'elenco in atto anziché restituirne uno nuovo, si tratta solo di una chiamata .ForEach () .

Per capire davvero come funziona, pensa più in termini di IEnumerable che in Elenchi. Pensa al motivo per cui le due espressioni seguenti hanno lo stesso risultato e perché quest'ultima è generalmente preferibile:

MyEnumerable.Count() > 2
MyEnumerable.Skip(2).Any()

Per raggiungere questo obiettivo, implementare nuovamente alcune estensioni IEnumerable standard usando la parola chiave yield di C #. Una volta capito perché il 2 ° si comporta meglio, dovresti essere in buona forma.

Per quanto riguarda i diversi tipi di delegati di base, devi solo impararli. Pensa a Func come al tuo delegato comune di base, dove specifichi il tipo di argomento e il tipo restituito per i parametri di tipo generico. Quindi pensa a Action come a un caso speciale di Func in cui il tipo restituito è nullo e Predicate come a un caso speciale in cui il tipo restituito è bool.

Answer 3

Le estensioni sono implementate in una classe statica con metodi statici che prendono la destinazione dell'estensione come primo parametro preceduto da questa parola chiave. Per implementare il tuo esempio, farei:

public static class ListBoxExtensions
{
  public static List<TextBox> SetToValue(this List<TextBox> txtBoxes, string sValue)
  {
    txtBoxes.ForEach(txtBox => txtBox.Text = sValue);
    return txtBoxes;
  }
}

e per usarlo su un modulo Windows con 3 caselle di testo:

private void Form1_Load(object sender, EventArgs e)
{
  List<TextBox> boxes = new List<TextBox>
                        {
                          textBox1,
                          textBox2,
                          textBox3
                        }.SetToValue("Hello");
}

Scusa, non parlare VB.

Spero che questo aiuti.