Ecriture de méthodes d'extension avec Action / Func / Delegates / Lambda en VB et C #

Question

Premièrement, je ne comprends pas très bien les aspects fonctionnels / Lambda de .NET 3.5. J'utilise ces fonctionnalités tous les jours dans LINQ, mais mon problème est de comprendre leur implémentation et ce qu'elles signifient vraiment (Lambda? System.Func? Etc. etc.)

Dans cet esprit, comment pourrait-on atteindre les objectifs suivants:

Par exemple, j'aimerais une méthode d'extension pour List (Of T) qui définit les propriétés de tous les objets de la liste sur une certaine valeur et renvoie la liste (Of T) mise à jour. Cela s'appellerait comme ceci:

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

À quoi ressemblerait la méthode d'extension, à la fois en VB et en C #?

i.e:

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

acclamations!

MODIFIER

Comme beaucoup l'ont fait remarquer, l'objectif ci-dessus peut être atteint plus ou moins avec .ForEach (). Mais mon intérêt est de comprendre comment quelque chose comme .ForEach () est implémenté, c’est-à-dire que je suis intéressé par l’implémentation de la solution au problème ci-dessus.

Answer 1

Vraiment, vous utilisez ici des méthodes d’extension correspondantes. C'est presque une combinaison de Select et ForEach. Il semble que vous souhaitiez une méthode qui vous permette à la fois de modifier les éléments d’une liste et de renvoyer l’énumération initiale. Ce qui suit devrait faire l'affaire pour vous.

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

À l'exception du fait que vous modifieriez la liste à la place plutôt que d'en retourner une nouvelle, il s'agit simplement d'un appel .ForEach () .

Pour vraiment comprendre comment cela fonctionne, pensez plus en termes de IEnumerable que de Listes. Réfléchissez aux raisons pour lesquelles les deux expressions ci-dessous ont le même résultat et , pourquoi cette dernière est généralement préférable:

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

Pour ce faire, réimplémentez certaines extensions IEnumerable standard à l'aide du mot clé yield de C #. Une fois que vous avez vraiment compris pourquoi le deuxième donne de meilleurs résultats, vous devriez être en forme.

En ce qui concerne les différents types de délégués de base, il vous suffit de les apprendre. Pensez à Func en tant que délégué commun de base, dans lequel vous spécifiez le type d'argument et le type de retour pour les paramètres de type générique. Imaginez ensuite Action comme cas particulier de Func où le type de retour est void et Predicate comme un cas particulier où le type de retour est bool.

Answer 3

Les extensions sont implémentées dans une classe statique par des méthodes statiques qui prennent la cible de l'extension comme premier paramètre précédé du mot-clé this. Pour implémenter votre exemple, je ferais:

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

et à utiliser ceci sur un formulaire Windows avec 3 zones de texte:

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

Désolé, ne parlez pas VB.

J'espère que cela vous aidera.