Search results for 'app:weblogs' matching tag 'Lambda'

Lambda Expressions: Execution

DeborahK — Fri, 16 Oct 2009 05:00:00 GMT

Lambda expressions can be assigned to a delegate variable. The lambda expression is then executed when the delegate is called.

[To begin with an overview of lambda expressions, start here.]

In the following example, a lambda expression is assigned to a variable (f).

In C#:

Func<int,string> f = x => (x + x).ToString();
Debug.WriteLine(f(5));
Debug.WriteLine(f(10));

In VB:

Dim f = Function(x as Integer) (x + x).ToString()
Debug.WriteLine(f(5))
Debug.WriteLine(f(10))

The lambda expression in this example is a Func<int, string> [Func(Of Integer, String) in VB] meaning it takes one integer input parameter and returns a string. The lambda expression simply takes the input value, adds it to itself, and returns the result as a string.

[For more information on Func delegates, see this post.]

When the expression is defined, it is not executed. It is not executed until it is called.

The first Debug.WriteLine statement calls the lambda expression, passing in a 5. The result displays "10" in the debug window.

The second Debug.WriteLine statement calls the lambda expression again, passing in a 10. The result displays "20" in the debug window.

Lambda expressions are executed when they are called, not when they are constructed. This is important to consider, especially when the lambda expression contains local variables.

Local variables used in a lambda expression are “captured” or “lifted”. The variable value used is the value at execution time. The variable lifetime extends to the lifetime of the delegate.

The following code updates the original example to use a local variable.

In C#:

int y = 0;
Func<int,string> f = x => (x + y).ToString();
y = 10;
Debug.WriteLine(f(5));

In VB:

Dim y As Integer = 0
Dim f = Function(x) (x + y).ToString()
y = 10
Debug.WriteLine(f(5))

The lambda expression in this example takes the input value, adds it to the current value of the local variable (y), and returns the result as a string.

The Debug.WriteLine statement in this example calls the lambda expression, passing in a 5. At the point of executing the Debug statement, y is 10, so the result displays "15" in the debug window.

For another example of using lambda expressions with local variables, see this post.

Enjoy!

Delegates

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

A delegate is an object that holds a reference to a method with a particular parameter list and return type.

It is basically like an object-oriented, type-safe function pointer.

Delegates basically make it possible to treat methods as entities. You can then assign a delegate to a variable or pass it as a parameter.

The classic delegate example uses events.

In C#:

HelloButton.Click += new EventHandler(HelloButton_Click);

Or the short-cut version of this code:

HelloButton.Click += HelloButton_Click;

This passes the HelloButton_Click method to a new EventHandler delegate.

In VB:

AddHandler HelloButton.Click, AddressOf HelloButton_Click

In VB, the AddressOf assigns the address of the HelloButton_Click method to the delegate.

Instead of using a named method for the delegate (in this example, a HelloButton_Click method), you can use a lambda expression.

In C#:

HelloButton.Click += (s, ev) =>
MessageBox.Show("Hello World");

In VB:

AddHandler HelloButton.Click, Function(s, ev) _
MessageBox.Show("Hello World")

In this case the lambda expression has two parameters: s (sender) and ev (eventArgs). When the Click event is generated on the HelloButton, the code displays the MessageBox.

You can use a lambda expression (inline function) anywhere a delegate is required. However, if the function requires more than a few lines of code, a named method is the preferred and recommended technique.

Enjoy!

Lambda Expressions: Func Delegates

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

A Func delegate encapsulates a method that returns a value. It takes up to four parameters (and this number is increased in .NET 4.0) plus the return value.

[To begin with an overview of lambda expressions, start here.]

The following signature is a Func delegate that takes two integer parameters and returns a string.

In C#:

Func<int, int, string>

In VB:

Func(Of Integer, Integer, String)

There are many examples of Func delegates.

The following code demonstrates the Sum function that sums the sales total for all customers in the list (and assumes that a Customer object has a SalesTotal property).

In C#:

var total = custList.Sum(c =>
c.SalesTotal);

In VB:

Dim total = custList.Sum(Function(c) _
c.SalesTotal)

Enjoy!

Lambda Expressions: Action Delegates

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

Just as the name implies, an action delegate encapsulates a method that performs an action and has no return value. It takes up to four parameters (and this number is increased in .NET 4.0).

[To begin with an overview of lambda expressions, start here.]

The ForEach method of the List<T> is an example of an action delegate. It takes an action delegate as a parameter.

One of the common uses of ForEach is to display all of the elements in a list using one line of code.

In C#:

custList.ForEach(c =>
Debug.WriteLine(c.LastName));

In VB:

custList.ForEach(AddressOf WriteToDebug)

NOTE: VB lambda expressions do not currently support action delegates. In the above example, the code uses a named method as the action delegate. VB 10 lambda expressions will support action delegates using the Sub keyword instead of the Function keyword.

Enjoy!

Lambda Expressions: Predicate Delegates

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

According to Wikipedia, a predicate is “a function which returns a Boolean value”.

[To begin with an overview of lambda expressions, start here.]

A predicate delegate encapsulates a method that evaluates to True or False. It takes a single parameter.

The Array class Find method is an example of a predicate delegate. It takes an array as a first parameter and a predicate delegate as its second parameter.

In C#:

var foundCustomer = Array.Find(custArray, c =>
c.LastName.StartsWith("K"));

In VB:

Dim foundCustomer = Array.Find(custArray, Function(c) _
c.LastName.StartsWith("K"))

This code iterates through the array, checking each entry and evaluating the expression as true or false. If the expression is false, it continues. If the expression is true, it returns the entry. Basically, this code finds the first customer in the array with a last name that starts with the defined letter.

Enjoy!

Lambda Expressions: Syntax

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

This post covers the syntax for lambda expressions. It uses the customer list defined in this prior post.

[To begin with an overview of lambda expressions, start here.]

The first example below uses the FirstOrDefault extension method on the Enumerable object to find the first customer that matches the defined expression. The FirstOrDefault method takes a delegate as a parameter and that delegate is defined with a lambda expression.

In C#:

' General syntax:
Customer foundCustomer =
custList.FirstOrDefault((Customer c) =>
c.CustomerId == 4);)

' With inferred typing:
var foundCustomer =
custList.FirstOrDefault(c => c.CustomerId == 4);)

The lambda expression in this example is as follows:

c => c.CustomerId == 4

The code begins with the set of parameters to the lambda expression. In this example, there is one parameter (c). The => is the “goes to” or lambda operator. The remainder of the code is the expression itself. In this case, checking for the item in the list where CustomerId is 4.

In VB:

' General syntax:
Dim foundCustomer as Customer = _
custList.FirstOrDefault(Function(c as Customer) _
c.CustomerId = 4)

' With inferred typing:
Dim foundCustomer = _
custList.FirstOrDefault(Function(c) _
c.CustomerId = 4)

The lambda expression in this example is as follows:

Function(c) c.CustomerId = 4

The code begins with the word “Function” along with the set of parameters to the lambda expression. In this example, there is one parameter (c). The remainder of the code is the expression itself. In this case, checking the item in the list where CustomerId is 4.

In either language, notice the shorter syntax with inferred typing. The compiler recognizes that the list contains customers, so it can infer the type of the parameter and the type of return value.

You can combine some of the extension methods to form more complex statements.

In C#:

var query = custList.FindAll(c =>
c.LastName.StartsWith(“K”)).OrderBy(c => c.FirstName));

In VB:

Dim query = custList.FindAll(Function(c) _
c.LastName.StartsWith(“K”)). _
OrderBy(Function(c) c.FirstName))

This code finds all of the entries that match the first lambda expression, basically all customers with a last name that begins with “K”. The code then performs an OrderBy using the second lambda expression, basically sorting the resulting list by first name.

The above examples demonstrate single-line lambdas. You can also use multi-line lambdas as shown in the example below.

In C#:

var foundCustomer =
    custList.FirstOrDefault(c =>
{
   Debug.WriteLine(c.LastName);
   if (c.CustomerId == 4)
      return true;
   else
      return false;
});

In VB:

Not available in VB9, coming in VB10.

Multi-line lambda expressions require the standard {} syntax to define the statement block. Whereas single-line lambda expressions automatically handle the return value for you, you have to handle it yourself in multi-line lambda expressions.

Enjoy!

Lambda Expressions: Finding an Item in a Generic List

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

In this prior post, I detailed how to build lists of things using a generic List<T>. Once you have a list, you may need to find items in the list. There are several ways to accomplish this, but using lambda expressions is the most concise.

[To begin with an overview of lambda expressions, start here.]

For example, here is how you find an item in a generic list using a for/each statement.

In C#:

Customer foundCustomer = null;
foreach (var c in custList)
{
    if (c.CustomerId == 4)
    {
        foundCustomer = c;
        break;
    }
}
Debug.WriteLine(foundCustomer);

In VB:

Dim foundCustomer As Customer = Nothing
For Each c As Customer In custList
    If c.CustomerId = 4 Then
        foundCustomer = c
        Exit For
    End If
Next
Debug.WriteLine(foundCustomer)

Notice the amount of code required to loop through each item in the list and find the one with a particular customer Id.

You may have heard about language integrated query (LINQ) and how you can use it to search a list.

In C#:

Customer foundCustomer = null;
var query = from c in custList
where c.CustomerId == 4
select c;
foundCustomer = query.FirstOrDefault();
Debug.WriteLine(foundCustomer);

In VB:

Dim foundCustomer As Customer = Nothing
Dim query = From c As Customer In custList _
Where c.CustomerId = 4 _
Select c
foundCustomer = query.FirstOrDefault()
Debug.WriteLine(foundCustomer)

So LINQ is cool, but the code does not seem much shorter.

Now let’s look at using lambda expressions to find the item in the list.

In C#:

Customer foundCustomer = null;
foundCustomer = custList.FirstOrDefault(c =>
c.CustomerId == 4);
Debug.WriteLine(foundCustomer);

The lambda expression syntax in C# looks like this:

c => c.CustomerId == 4

The code begins with the set of parameters to the lambda expression. The => is the “goes to” or lambda operator. The remainder of the code is the expression itself. In this case, checking for the item in the list where CustomerId is 4.

In VB:

Dim foundCustomer As Customer = Nothing
foundCustomer = custList.FirstOrDefault(Function(c)
c.CustomerId = 4)
Debug.WriteLine(foundCustomer)

The lambda expression syntax in VB looks like this:

Function(c) c.CustomerId = 4

The code begins with the word “Function” along with the set of parameters to the lambda expression. The remainder of the code is the expression itself. In this case, checking the item in the list where CustomerId is 4.

.NET 3.5 added a large list of extension methods on the Enumerable class. Any object that implements IEnumerable or IEnumerable<T> (basically any object you can do a for/each over) can use these methods. Many of these extension methods (such as the FirstOrDefault method shown in the above example) support lambda expressions.

The FirstOrDefault extension method of the Enumerable class returns the first item in the list or the default value for the object. If you pass it a lambda expression, it returns the first item in the list that matches the Boolean expression.

Enjoy!

Lambda Expressions: An Introduction

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

My presentation at our local Code Camp was fun. I covered a lot of material and had a GREAT audience. Several people have asked for the slide information in my blog. So this is the start of several posts on lambda expressions.

In addition, I wrote an article on lambda expressions that should appear in the Jan/Feb 2010 issue of Code Magazine. I’ll post the link as soon as its published.

Lambda expressions are unnamed, inline functions. They are new in Visual Basic 9 and C# 3.0 (VS 2008). You can use a lambda expression anywhere a delegate is required. For more information on delegates, see this post.

Here are an additional set of posts that cover the slides and information from my talk:

Enjoy!

Enumerable.Repeat

DeborahK — Fri, 04 Sep 2009 05:00:00 GMT

The Enumerable class is new in .NET 3.5 and is part of the System.Linq namespace. It provides a set of static methods that allow you to query any object that implements IEnumerable, basically meaning any object that supports a for/each.

This post focuses on the Repeat method of the Enumerable class and some of the helpful things that this class can do for you.

NOTE: Be sure to set a reference to System.Core.

First, at the top of your code file, add this code.

In C#:

using System.Linq;

In VB:

Imports System.Linq

(Or for VB you can import a namespace using the project properties.)

You can then use the Enumerable.Repeat as shown in the following examples.

In C#:

// Initialize an array to -1 for each of 10 elements
int[] all1 = Enumerable.Repeat(-1, 10).ToArray();

// Initialize an array to "A" for each of 10 elements
string[] allA = Enumerable.Repeat("A", 10).ToArray();

// Convert a single value to an array
int value = 42;
int[] valueArray = Enumerable.Repeat(value, 1).ToArray();

// Generate 10 random numbers
Random rand = new Random();
int[] randomArray = Enumerable.Repeat(0, 10).Select(
i => rand.Next(0,10)).ToArray();

// Initialize a list with 5 Customer objects
List<Customer> custList = Enumerable.Repeat(
new Customer(), 10).ToList();

In VB:

' Initialize an array to -1 for each of 10 elements
Dim all1() As Integer = Enumerable.Repeat(-1, 10).ToArray()

' Initialize an array to "A" for each of 10 elements
Dim allA() As String = Enumerable.Repeat("A", 10).ToArray()

' Convert a single value to an array
Dim value As Integer = 42
Dim valueArray() As Integer = Enumerable.Repeat(value, 1).ToArray()

' Generate 10 random numbers
Dim rand As Random = New Random()
Dim randomArray() As Integer = Enumerable.Repeat(0, 10).Select( _
Function(i) rand.Next(0, 10)).ToArray()

' Initialize a list with 5 Customer objects
Dim custList As List(Of Customer) = Enumerable.Repeat( _
New Customer(), 10).ToList()

The first example initializes an array of 10 integers to –1.

The second example initializes an array of 10 strings to "A".

The third example takes a single value and creates an array from it. This is often necessary when a method requires an array instead of a single element.

The random number example provides another way to generate a random numbers. In this case, it generates 10 random numbers between 0 and 9. Note that this does not ensure uniqueness, so the number 2 for example could occur multiple times in the list.

The last example initializes a list of business objects to an empty set of objects. You could use object initializer syntax in this example to initialize all of the objects to some set of values, such as setting the State = "CA". This could be useful in setting up data for testing or prototyping.

Use the Repeat method any time you want to repeat values in an array or list.

Enjoy!

Enumerable.Range

DeborahK — Fri, 04 Sep 2009 05:00:00 GMT

This post focuses on the Range method of the Enumerable class and some of the helpful things that this class can do for you.

NOTE: Be sure to set a reference to System.Core.

First, at the top of your code file, add this code.

In C#:

using System.Linq;

In VB:

Imports System.Linq

(Or for VB you can import a namespace using the project properties.)

You can then use the Enumerable.Range as shown in the following examples.

In C#:

// Initialize an array of numbers 0 - 9
int[] numbers = Enumerable.Range(0, 10).ToArray();

// Initialize an array with any arithmetic sequence
// This one does 10, 20, 30 ... 100
int[] arithmetic = Enumerable.Range(0, 10).Select(
i => 10 + (10 * i)).ToArray();

// Initialize an array with any geometric sequence
// This one does 2, 6, 18, ... 39366
int[] geometric = Enumerable.Range(0, 10).Select(
i => 2 * (int)Math.Pow(3,i)).ToArray();

// This one does 10, 5, 2.5, ... 0.01953125
double[] geometric2 = Enumerable.Range(0, 10).Select(
i => 10 * Math.Pow(.5, i)).ToArray();

// Initialize an array with letters
// This one does A, B, ... J
string[] letters = Enumerable.Range(0, 10).Select(
i => ((char)('A' + i)).ToString()).ToArray();

// This one does z, y, ... q
string[] letters2 = Enumerable.Range(0, 10).Select(
i => ((char)('z' - i)).ToString()).ToArray();

In VB:

' Initialize an array of numbers 0 - 9
Dim numbers() As Integer = Enumerable.Range(0, 10).ToArray()

' Initialize an array with any arithmetic sequence
' This one does 10, 20, 30 ... 100
Dim arithmetic() As Integer = Enumerable.Range(0, 10).Select( _
Function(i) 10 + (10 * i)).ToArray()

' Initialize an array with any geometric sequence
' This one does 2, 6, 18, ... 39366
Dim geometric() As Integer = Enumerable.Range(0, 10).Select( _
Function(i) CType(2 * (3 ^ i), Integer)).ToArray()

' This one does 10, 5, 2.5, ... 0.01953125
Dim geometric2() As Double = Enumerable.Range(0, 10).Select( _
Function(i) 10 * (0.5 ^ i)).ToArray()

' Initialize an array with letters
' This one does A, B, ... J
Dim letters() As String = Enumerable.Range(0, 10).Select( _
Function(i) (Chr(Asc("A") + i)).ToString()).ToArray()

' This one does z, y, ... q
Dim letters2() As String = Enumerable.Range(0, 10).Select( _
Function(i) (Chr(Asc("z") - i)).ToString()).ToArray()

Note: Even though all of the above examples use ToArray to build an array, you could instead build lists using ToList.

The first example uses the basics of the Range to build an array of integers. You can use this syntax to build any range of integers.

The other examples combine the Range method with a lambda expression to build other types of numeric arrays.

The arithmetic sequence example demonstrates how to build an array where the difference between each term is a constant. In this example, the constant is 10.

The geometric sequence examples demonstrates how to build any array where each term after the first is generated by multiplying the previous one by a fixed non-zero number (common ratio). In the first example, the common ratio is 3. In the second example, the common ratio is 1/2.

The alphabetic sequence uses the fact that the Unicode characters for the letters in the alphabet are in numerical sequence. So adding 1 to 'A' gives you 'B' and so on.

Use the Range method any time you want to build a list or array of values in a logical sequence.

Enjoy!