Visual Basic .NET - Delegates and Lambda Expressions in VB.NET

Delegates and lambda expressions are advanced features in VB.NET that help developers write flexible and reusable code. They are especially useful in event handling, callbacks, filtering data, and passing methods as arguments. These concepts are widely used in modern .NET applications because they simplify coding patterns that otherwise require extra classes or methods.

What is a Delegate?

A delegate is a special type in VB.NET that holds a reference to a method. In simple terms, a delegate acts like a pointer to a function. It allows a method to be stored in a variable and called later. The method assigned to a delegate must have the same return type and parameter list as the delegate definition.

This makes delegates useful when one method needs to call another method dynamically. Instead of hardcoding which function to execute, the program can decide at runtime which method to use.

Why Delegates are Important

Delegates are important because they allow methods to be treated like objects. This means a method can be passed to another method as a parameter. This is very useful in scenarios such as event handling, where a program needs to execute certain actions when a user clicks a button or when a process completes.

For example, in a Windows application, when a user presses a button, the program can use a delegate to call the event-handling method. The delegate links the button action with the code that should run.

Declaring a Delegate

A delegate is declared using the Delegate keyword. The syntax defines the signature of the method it can point to.

Example:

Delegate Sub DisplayMessage(ByVal msg As String)

This means the delegate can point to any method that accepts one string parameter and returns nothing.

Assigning a Method to a Delegate

Once the delegate is declared, a method with the same signature can be assigned to it.

Example:

Module Program
    Delegate Sub DisplayMessage(ByVal msg As String)

    Sub Show(ByVal text As String)
        Console.WriteLine(text)
    End Sub

    Sub Main()
        Dim d As DisplayMessage = AddressOf Show
        d("Welcome to VB.NET")
    End Sub
End Module

In this example, the Show method is assigned to the delegate. When the delegate is called, it executes the Show method.

Multicast Delegates

A multicast delegate can hold references to multiple methods. This means one delegate can call several methods one after another. This is useful when one action should trigger multiple operations.

Example:

Module Program
    Delegate Sub Notify()

    Sub Message1()
        Console.WriteLine("First Message")
    End Sub

    Sub Message2()
        Console.WriteLine("Second Message")
    End Sub

    Sub Main()
        Dim n As Notify
        n = AddressOf Message1
        n += AddressOf Message2
        n()
    End Sub
End Module

Here, calling n() executes both Message1 and Message2.

Anonymous Methods

An anonymous method is a method without a name. It is often used when a method is needed only once. This reduces the need to create separate named procedures.

VB.NET supports anonymous methods through inline code blocks, especially in delegate assignments.

Example:

Dim greet As Action = Sub()
                          Console.WriteLine("Hello")
                      End Sub
greet()

This creates a delegate directly without defining a separate method.

What are Lambda Expressions?

Lambda expressions are shorter ways to write anonymous methods. They allow developers to define functions directly where they are needed. Lambda expressions improve readability and reduce code length.

A lambda expression can return values or perform actions. It is widely used in LINQ and event handling.

Syntax of Lambda Expressions

The basic syntax uses the Function or Sub keyword.

Example with Function:

Dim square = Function(x As Integer) x * x
Console.WriteLine(square(5))

Output:

25

Example with Sub:

Dim print = Sub(name As String)
                Console.WriteLine(name)
            End Sub
print("VB.NET")

Types of Lambda Expressions

There are two main types:

  1. Single-line lambda
    Contains one expression.

  2. Multi-line lambda
    Contains multiple statements.

Single-line example:

Dim add = Function(a As Integer, b As Integer) a + b

Multi-line example:

Dim calculate = Function(x As Integer)
                    Dim result = x * 2
                    Return result
                End Function

Delegates with Lambda Expressions

Lambda expressions are often assigned directly to delegates. This combines flexibility with simpler syntax.

Example:

Delegate Function Operation(ByVal a As Integer, ByVal b As Integer) As Integer

Module Program
    Sub Main()
        Dim op As Operation = Function(x, y) x + y
        Console.WriteLine(op(10, 20))
    End Sub
End Module

The lambda function is assigned directly to the delegate.

Using Built-in Delegates

.NET provides built-in delegates that reduce the need to create custom ones.

Common built-in delegates:

  • Action – Represents methods that return no value.

  • Func – Represents methods that return a value.

  • Predicate – Represents methods that return Boolean values.

Example:

Dim multiply As Func(Of Integer, Integer, Integer) = Function(a, b) a * b
Console.WriteLine(multiply(4, 5))

Output:

20

Delegates in Event Handling

Delegates are the foundation of events in VB.NET. Every event internally uses delegates. When an event occurs, the associated delegate calls the assigned method.

Example:

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    MessageBox.Show("Button Clicked")
End Sub

Here, the event handler works through delegates.

Benefits of Delegates

Delegates provide several advantages:

  • Enable methods to be passed as arguments

  • Support dynamic method invocation

  • Improve event handling

  • Allow loose coupling between components

  • Increase code reusability

They make applications more modular and adaptable.

Benefits of Lambda Expressions

Lambda expressions simplify programming by:

  • Reducing code size

  • Improving readability

  • Supporting quick function creation

  • Enhancing LINQ queries

  • Eliminating unnecessary method definitions

They are particularly useful when small logic needs to be used once.

Practical Uses

Delegates and lambda expressions are used in many real applications:

  • Event-driven applications

  • Background task execution

  • Sorting and filtering collections

  • Callback methods

  • Database querying with LINQ

  • GUI programming

  • Data processing

For example, filtering a list using lambda:

Dim numbers = {1, 2, 3, 4, 5}
Dim even = numbers.Where(Function(x) x Mod 2 = 0)

For Each n In even
    Console.WriteLine(n)
Next

This filters only even numbers.

Difference Between Delegates and Lambda Expressions

A delegate defines the structure of a method reference. A lambda expression is a shortcut for creating methods inline. They work together, but their roles are different.

Delegate:

  • Defines method signature

  • Stores method reference

Lambda:

  • Creates inline anonymous method

  • Can be assigned to delegate

Conclusion

Delegates and lambda expressions are essential features in VB.NET that support flexible and modern programming practices. Delegates allow methods to be passed and executed dynamically, while lambda expressions make coding shorter and easier by allowing inline function definitions.

Together, they play a major role in event handling, collection processing, and advanced application design. Understanding these concepts helps developers write more efficient, reusable, and maintainable VB.NET applications.