Escribir métodos de extensión con Action / Func / Delegates / Lambda en VB y C #

Question

En primer lugar, no puedo entender los aspectos funcionales / Lambda de .NET 3.5. Utilizo estas funciones todos los días en LINQ, pero mi problema es comprender la implementación y lo que realmente significan (Lambda? System.Func? Etc etc.)

Teniendo esto en cuenta, ¿cómo se lograría lo siguiente?

Como ejemplo, me gustaría tener un método de Extensión para Lista (Of T) que establezca las propiedades de todos los objetos en la Lista a un cierto valor y devuelva la Lista actualizada (Of T). Se llamaría así:

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

¿Qué aspecto tendría el método de extensión, tanto en VB como en C #?

es decir:

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

¡salud!

EDIT

Como muchos han señalado, lo anterior se puede lograr, más o menos, con .ForEach (). Pero mi interés es entender cómo se implementa algo como .ForEach (), es decir, estoy interesado en la implementación de la solución para el problema anterior.

Answer 1

Realmente estás haciendo mike y haciendo coincidir los métodos de extensión aquí. Es casi una combinación de Select y ForEach. Parece que desea un método que le permita modificar los elementos de una lista y devolver la enumeración original. Lo siguiente debería hacer el truco por ti.

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 la excepción de que modificaría la lista en su lugar en lugar de devolver una nueva, esto es solo una llamada a .ForEach () .

Para comprender realmente cómo funciona esto, piense más en términos de IEnumerable s que en Lists. Piense por qué las dos expresiones a continuación tienen el mismo resultado y por qué la última es generalmente preferible:

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

Para ayudar a lograr esto, vuelva a implementar algunas extensiones IEnumerable estándar usando la palabra clave yield de C #. Una vez que entienda realmente por qué el segundo desempeño es mejor, debería estar en buena forma.

En cuanto a los diferentes tipos de delegados básicos, solo necesitas aprenderlos. Piense en Func como su delegado común básico, donde especifica el tipo de argumento y el tipo de retorno para los parámetros de tipo genérico. Luego piense en Action como un caso especial de Func donde el tipo de devolución es nulo y Predicate como un caso especial donde el tipo de devolución es bool.

Answer 3

Las extensiones se implementan en una clase estática mediante métodos estáticos que toman el objetivo de la extensión como el primer parámetro precedido por esta palabra clave. Para implementar tu ejemplo yo haría:

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

y para usar esto en un formulario de Windows con 3 cuadros de texto:

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

Lo siento, no hables VB.

Espero que esto ayude.