Forem: Ravi Sankar Rao

C# Delegates Simplified — Part 3

Ravi Sankar Rao — Thu, 14 Sep 2023 05:35:18 +0000

This article is the third one from a series of 3 articles on C# delegates. If you are new to delegates and haven’t gone through the previous ones, I suggest you to go through them first

Part 1
Part 2

We all might have read articles that say “If you are using lambda expressions in C#, you are already working with delegates” but they don’t discuss anything about how they are closely related.

In this article we will discuss the journey from delegate to lambda expressions.

Below we have a person class with two properties.

public class Person
{
        public string FirstName { get; set; }
        public string LastName { get; set; }
}

We have a function somewhere outside this class which takes a Person parameter and returns formatted name

public string GetFullName(Person person)
{
       return $"{person.FirstName} {person.LastName}";
}

Lets declare a delegate for the function which should match the signature.

public delegate string PersonFormatter(Person person);

Using above delegate with our function will be like this

var person = new Person { FirstName = "John", LastName = "Doe" };

PersonFormatter formatter = GetFullName;
var fullName = formatter(person);

Here we have a separate function for our delegate, but for most of our day-to-day programming we don’t need to write a separate function for our delegate to be used.

We can achieve use a delegate by using something known as Anonymous functions in C#. Below is how we can do that.

PersonFormatter formatter = delegate (Person person)
{
       return $"{person.FirstName} {person.LastName}";
};

// No changes in the way delegate is invoked
var fullName = formatter(person);

The syntax has 4 major parts

a variable named formatter of type PersonFormatter
use of delegate keyword
Person variable in round brackets
a function body that does the same as our GetFullName function earlier. This function body does not has a name, hence an Anonymous function.

We can simplify the use of anonymous function while we initialize our delegate. We can get rid of the ‘delegate’ keyword and use ‘=>’ which is commonly knows as ‘goes to’ operator or famously in our case as the ‘lambda’ operator.

PersonFormatter formatter = (Person person) =>
{
        return $"{person.FirstName} {person.LastName}";
};

We removed the delegate keyword, and added a lambda operator after our Person variable.

We can simplify this even more. Taking advantage of C#’s Type Inference, we can also get rid of the Person type and just use a parameter name as shown below.

PersonFormatter formatter = (person) =>
{
        return $"{person.FirstName} {person.LastName}";
};

We got rid of the type Person, and are just using person as a parameter . C#’s Type inference automatically kicks in due to the delegate type PersonFormatter that the parameter it needs is of Person type.

Interesting till now ? More on the way.

We can simplify this even further. It happens, if we are working with single parameter delegates, we don’t even need the brackets around the parameter as well.

PersonFormatter formatter = person =>
{
        return $"{person.FirstName} {person.LastName}";
};

Below, I have renamed person to ‘p’ for simplification.

PersonFormatter formatter = p =>
{
        return $"{p.FirstName} {p.LastName}";
};

This is what we call as “Statement Lambdas”, meaning expressions are enclosed in braces.

We can simplify this even further. If our anonymous function body has only one statement, we can get rid of curly brackets and the return keyword as well.

PersonFormatter formatter = p => $"{p.FirstName}{p.LastName}";

This is called as “Expression Lambdas”

If we are working with more that one parameters, we have to use brackets around our parameter

public delegate int DoSomeMath(int a, int b);

// Below is to add two numbers
DoSomeMath someMath = (a, b) => a + b;

Hope the articles helped to bridge the gap between delegates and lambda expressions.

C# Delegates Simplified — Part 2

Ravi Sankar Rao — Thu, 14 Sep 2023 05:23:31 +0000

This article is the second one of a series of 3 articles on C# delegates. If you haven’t gone through the part 1, I suggest you to go through it first.

In the previous article we went through a brief intro on what delegates are, how are they declared, initialized and invoked. Here we will take a simple use case where delegates can be useful.

One thing which the previous article did not mention is that, we use delegates majorly to pass functions as parameters. We will work on this usage here.

We have a Person class with FirstName and LastName as its member properties. The requirement is to get a person’s name in different formats. For one of the case, we have overridden ToString as below.

public class Person
{
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public override string ToString()
        {
            return $"{this.FirstName} {this.LastName}";
        }
}

I created a small WPF application to demonstrate this. Screenshot of the UI is below. It has a set of radio buttons to select a format, then on click of “Display Name” button, names should be displayed within the list box on the right as per the selected format radio button.

Coming back to our Person class. In order for the class to support different formats of name, one way we can achieve this is by creating a parameterized ToString method in the class, send some kind of enum to decide in which format we need to return, add a switch case, construct that format and return the formatted name. Below is how this can be done.

public enum FormatType
{
        Default = 1,
        LastNameFirst,
        LastNameOnly,
        FirstNameOnly,
        InitialsOnly
}

public class Person
{
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public override string ToString()
        {
            return $"{this.FirstName} {this.LastName}";
        }

        public string ToString(FormatType format)
        {
            switch (format)
            {
                case FormatType.Default:
                    return this.ToString();
                case FormatType.LastNameFirst:
                    return $"{this.LastName} {this.FirstName}";
                case FormatType.LastNameOnly:
                    return this.LastName;
                case FormatType.FirstNameOnly:
                    return this.FirstName;
            }
            return default;
        }
}

Though above design would work fine but there is a problem with that. Every time we need a new format to be added, we need modify Person’s ToString method to add one more case for a new format type.

This goes against the Open-Close principle of SOLID design which states that a software entity (Person class in this case) should be open for extension but closed for modification.

This also goes against Single Responsibility principle of SOLID which states an entity should have responsibility for a single part of the program. In this case the responsibility of Person class should only be of holding the data, and not what to do with this data.

We can address both the issues using delegates

Below is a modified Person class that uses a ToString method that takes a delegate as a parameter and returns a string. We invoke the delegate inside this method and return its result, in this case it being string.

public delegate string PersonFormatter(Person persion);
public class Person
{
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string ToString(PersonFormatter formatter)
        {
            return formatter(this);
        }
}

We can see how the Person class is now lean and does not do anything apart from storing information.

We create a NameFormatter class with different methods to format the name. This was we keep the name formatting code separate from Person class. It has four methods as per the radio buttons in our WPF UI.

public static class NameFormatter
{
        public static string Default(Person person)
        {
            return $"{person.FirstName} {person.LastName}";
        }
        public static string LastNameFirst(Person person)
        {
            return $"{person.LastName} {person.FirstName}";
        }
        public static string FirstNameOnly(Person person)
        {
            return person.FirstName;
        }
        public static string LastNameOnly(Person person)
        {
            return person.LastName;
        }
}

Remember the WPF app screenshot above ? In the code behind file, we have the following

List of persons which is dummy data — people
Local variable of type PersonFormatter delegate — formatter
Function which assigns the above formatter variable based on which radio button is selected.

List<Person> people = new List<Person>
{
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Tony", LastName = "Stark" }
};

public PersonFormatter formatter;

public void AssignFormatter()
{
            if (rdBtn_Default.IsChecked.Value)
                formatter = NameFormatter.Default;
            else if (rdBtn_LastNameFirst.IsChecked.Value)
                formatter = NameFormatter.LastNameFirst;
            else if (rdBtn_FirstNameOnly.IsChecked.Value)
                formatter = NameFormatter.FirstNameOnly;
            else if (rdBtn_LastNameOnly.IsChecked.Value)
                formatter = NameFormatter.LastNameOnly;
}

On click of the “Display Names” button, below function is invoked.

private void DisplayName_Click(object sender, RoutedEventArgs e)
{
            namesList.Items.Clear();   // clearing list box
            AssignFormatter();        // based on radio button  
            foreach (var person in people)
                namesList.Items.Add(person.ToString(formatter));
}

We clear all items from the listbox named as namesList
AssignFormatter function is invoked which assigns the type of formatter function to be assigned to our delegate variable formatter.
We iterate through people, and for each of the item we call it’s ToString method and pass our delegate formatter. If you remember, we had a ToString method which takes PersonFormatter delegate as a parameter

public string ToString(PersonFormatter formatter)
{
       return formatter(this);
}

Here the formatter is invoked which in turn invokes which ever NameFormatter function was assigned earlier in the AssignFormatter based on selected radio button. The result is returned as string.

This example is a fairly simple use of delegates but gives more of an idea how they are useful to follow SOLID design principles.

In the next article we discuss how delegates are related to lambda expressions.

C# Delegates Simplified — Part 1

Ravi Sankar Rao — Thu, 14 Sep 2023 05:11:37 +0000

This article is the first of a series of 3 articles on C# delegates.

Example we will be working with

Before directly jumping to delegates, lets take a look at the example. We have a static Maths class with two functions — FindSquare and FindSqrRoot. static here does not signify anything. It’s used just to simplify the course of this article.

public static class Maths
{
        public static double FindSquare(double number)
        {
            return number * number;
        }
        public static double FindSqrRoot(double number)
        {
            return Math.Sqrt(number);
        }
}

Both functions take a single parameter of type double, and both return double. Note that the signature of both methods is same because this will come into picture later.

We invoke these methods as per our need.

double number = 25;

Maths.FindSqrRoot(number);
Maths.FindSquare(number);

Coming to Delegates

Definition

If we go by the definition given in C# docs, A delegate is a type that represents references to methods with a particular parameter list and return type. To simplify it — a delegate is a type that defines a method signature.

How do we declare a delegate?

It is declared almost similar to a function except that it does not has a statement body for itself. It has a return type and might take parameters if required exactly like functions. Below is an example.

// No return type, No parameters
public delegate void MyDelegate();

// Has a return type, takes parameters
public delegate int MyDelegate(int someValue);

In our example, for the two methods if we declare a delegate, it will be as below.

public delegate double CalculationsWithSingleNumber(double number);

If you compare this with our two Maths functions, you will notice the signature is exactly the same, i.e. the return type and parameters are same.

Using a Delegate

Using a delegate is very simple too. We declare a variable of our delegate type and assign a function reference as it’s value. The delegate variable acts now as a function itself. We can invoke it just like a function, send our number and get the required result.

CalculationsWithSingleNumber doSomeMath = Maths.FindSquare;
double result = doSomeMath(10); // returns the square of the given number

doSomeMath = Maths.FindSqrRoot;
result = doSomeMath(25); // returns the square root of the given number

We can assign a function to a delegate which has the exact same signature.
Below is an example of function with two parameters. Trying to assign it to our delegate will result in compilation error with message saying — No overload for matches delegate

public static double AddNumbers(double a, double b)
{
     return a + b;
}

// This cannot be done since AddNumbers takes 2 parameters and the delegate takes only 1
CalculationsWithSingleNumber doSomeMoreMath = Maths.AddNumbers;

We saw how a delegate is declared, assigned and invoked, but one question that comes to mind is how we significantly use delegates in our programming.

Please visit article part 2 of this series for a simple example and implementation.