If you have been programming for any length of time, you may well have come across higher-order functions but (like me) may not have fully appreciated just how powerful they can be. If you've not heard of them before, never fear. I have an explanation below.

## What are higher-order functions?

Simply put, a higher-order function is a function whose input or output is also a function.

In the following example, the Map function takes a list of a particular data type and a function. It returns a new list with the function applied to each of the elements in the list (basically equivalent to the LINQs Select method).

\
``` csharp
// definition
List<TOut> Map<TIn, TOut>(List<TIn> list, Func<TIn, TOut> mapper)
{
    var newList = new List<TOut>();
    foreach (var item in list)
    {
        var newItem = mapper(item);
        newList.Add(newItem);
    }

    return newList;
}

// usage
var myList = new List<int> { 1, 2, 3, 4, 5 };

int multiplyBy2 (int num) => num * 2;
var multipliedList = Map(myList, multiplyBy2);
// output { 2, 4, 6, 8, 10 };

bool isEven (int num) => num % 2 == 0;
var isEvenList = Map(myList, isEven);
// output { false, true, false, true, false };
```

\
Here is an example of a higher-order function that returns a function. First, you call the Add function with a given integer, which returns a function that adds that first integer to any given other integer.

\
``` csharp
Func<int, int> Add(int a) => (int b) => a + b;
		
var add9 = Add(9);
		
var sum1 = add9(1);
// output 10

var sum2 = add9(2);
// output 11
```

\
Hopefully, by now, you can see why higher-order functions are so useful; they allow complex code to be reused in a highly flexible way by letting the client define their own input/output functions. For example, without using higher-order functions, one would have to define a new Map function for every type of mapping they needed.

## Practical Example - Repository Pattern

The repository pattern is a very common design pattern used as a data access abstraction. It allows you to perform your typical CRUD operations without the client having to interact directly with the data provider. A typical repository interface may look something like this:

\
``` csharp
public interface IProductRepository
{
    int Create(Product product);
    bool Update(Product product);
    bool Delete(int id);
    Product GetById(int id);
    IEnumerable<Product> GetAll();
    IEnumerable<Product> GetByCategoryId(int categoryId);
    IEnumerable<Product> GetActive();
    // etc...
}
```

\
As you can see in this typical example, there are numerous definitions that all return `IEnumerable<Product>`. Every time you need another specific type of product filter, that requires adding to the interface and writing an entirely new implementation. That's not great for maintainability...

\
Instead, using higher-order functions, we can define a single method that gets `IEnumerable<Product>` that takes a filter function as an input. That way, the client is free to define their own filters, and the ProductRepository doesn't need to keep being updated with new implementations.

\
``` csharp
interface IProductRepository
{
    // create, update, delete omitted
    
    IEnumerable<Product> Get(Func<Product, bool> filter = null);
}

public class ProductRepository : IProductRepository
{
    private readonly List<Product> _products = new List<Product>(); // data source

    public IEnumerable<Product> Get(Func<Product, bool> filter = null)
    {
        // typically you might use the LINQ Where method here
        // but using the foreach to be clear what is happening

        if (filter is null) return _products;     

        var filteredList = new List<Product>();
        foreach(var product in _products)
        {
            if(filter(product))
            {
                filteredList.Add(product);
            }
        }

        return filteredList;
    }
}
```

```
// client code
var allProducts = _productRepository.Get();
var productsByCategoryId = _productRepository.Get(p => p.CategoryId == 1);
var activeProducts = _productRepository.Get(p => p.Active);
```

## Conclusion

In this article, I have introduced the concepts of higher-order functions and demonstrated how they are extremely useful in creating reusable and flexible code that is easy to maintain and understand. I have also given a practical use case that you may find in a .NET enterprise application - making the repository pattern more reusable.

I post mostly about full-stack .NET and Vue web development. To make sure that you don't miss out on any posts, please follow this blog and [subscribe to my newsletter](https://samwalpole.com). If you found this post helpful, please like it and share it. You can also find me on [Twitter](https://twitter.com/dr_sam_walpole).


---

*Also published on <https://samwalpole.com/a-practical-guide-to-higher-order-functions-in-c>.*

Twitter

2022 - HackerNoon Contributor of the Year - Clean Code

2022 - HackerNoon Contributor of the Year - Dotnet

2022 - HackerNoon Contributor of the Year - Es6

2022 - HackerNoon Contributor of the Year - Functional Programming

Subscribe to my mailing list

Nominated for 2022 - HackerNoon Contributor of the Year - Es6

Nominated for 2022 - HackerNoon Contributor of the Year - Clean Code

Nominated for 2022 - HackerNoon Contributor of the Year - Dotnet

Nominated for 2022 - HackerNoon Contributor of the Year - Functional Programming

Too Long; Didn't Read

Cassandra Forward a free Cassandra-focused community event

Higher Order Functions in C#: A Practical Example

Higher Order Functions in C#: A Practical Example

Too Long; Didn't Read

Company Mentioned

@samwalpole

RELATED STORIES