Replace Foreach with LINQ
One of the best ways to start Thinqing in LINQ is to find places where you can replace iterative loops with LINQ queries. This won’t necessarily make your applications any faster at the moment, but by taking advantage of the declarative syntax, it will allow you to change your underlying implementation (ie. parallelize it with PLINQ) easier in the future. Recently, I came across some code that mimicked creating a control array as we used to have in VB6 by iterating over a list of fields and adding controls to a form adding the index to the end of the field name. As the fields are being added,we hook up event listeners along the way. Here’s the old code:
Dim Fields() As String = {"a", "one", "and", "a", "two"}
Dim index As Integer
For Each item As String In Fields
Dim box As New TextBox
With box
.Name = item + index.ToString
.Top = index * 30
.Height = 24
AddHandler .TextChanged, AddressOf OnValueChanged
End With
Controls.Add(box)
index += 1
Next
Dim Fields() As String = {"a", "one", "and", "a", "two"}
Dim b1 = From item In Fields
Select New TextBox With
{
.Name = item,
.Top = 30,
.Height = 24
}
Controls.AddRange(boxes)
In this example, we take our starting list. Project (Select) new objects from these values and then pass this list directly into the Controls collection using AddRange. No more For Each.
This is a start, but there's an issue. We need to be able to add the index to this set based operation. One of the little secrets in the LINQ operators is that there are overloads which expose the index. In VB, you can't access these using the LINQ query comprehensions. You have to use the extension methods and Lambda Functions directly as follows:
Dim Fields() As String = {"a", "one", "and", "a", "two"}
Dim boxes = Fields _
.Select(Function(item, index) _
New TextBox With {
.Name = item + index.ToString(),
.Top = index * 30,
.Height = 24})
Controls.AddRange(boxes.OfType(Of Control).ToArray)
We're almost there. We just need to add our handlers for each of our new text boxes. While we could call ForEach over an array, it would cause us to iterate over our field list twice (creating two sets of text boxes). We need a way to only iterate over it once. Here, we need to create a new method and using C# iterators. It will take an IEnumerable and return an IEnumerable. By using Yield, it will not cause the enumeration to happen multiple times, but rather to add a new step as each value is being pulled through the enumeration pipeline.
public static class Extensions
{
public static IEnumerable<T> WhileEnumerating<T>(this IEnumerable<T> source, Action<T> action)
{
foreach (T item in source)
{
action(item);
yield return item;
}
}
}
Now, we can inject methods into the pipeline as follows:
Dim boxes = Fields _
.Select(Function(item, index) _
New TextBox With {
.Name = item + index.ToString(),
.Top = index * 30,
.Height = 24}) _
.WhileEnumerating(Sub(item) AddHandler item.TextChanged, AddressOf OnValueChanged)
Controls.AddRange(boxes.OfType(Of Control).ToArray)
If we wanted to inject more functions, we would just add more .WhileEnumerating methods. Make sure however that each of these methods do not have side effects on other methods of the set. There you have it. Go search for those For Each (foreach) loops in your code and see how you can clean them up with LINQ to Objects.
