Functional Programming in C# - Functional Features

C# is a powerful and versatile language due to its multi-paradigm nature. This means it allows programmers to approach problems from different angles using various programming styles. Here's a breakdown of some paradigms C# supports:

Object-Oriented (OO)

This is a dominant paradigm in C#, with classes and objects forming the core structure for building applications. C# offers features like inheritance, polymorphism, and encapsulation, which are fundamental concepts of OO programming.

Imperative

This style focuses on giving step-by-step instructions to the computer, outlining how to achieve a specific outcome. C# excels in imperative programming with control flow statements (if/else, loops) and methods for manipulating data.

Functional

In functional programming, you emphasize functions and immutable data (data that doesn't change). C# supports functional constructs with lambda expressions, higher-order functions, and LINQ (Language Integrated Query).

Generic

This paradigm allows you to create code that works with various data types without rewriting it for each type. Generics in C# improve code reusability and maintainability.

Other paradigms

C# also supports concepts like concurrent programming (handling multiple tasks simultaneously) and metaprogramming (writing code that manipulates other code).

The benefit of C# being a multi-paradigm is that you can choose the approach that best suits the problem you're solving. For instance, you might use an object-oriented approach to design a user interface and then utilize functional programming for data processing tasks within that interface.

I’m planning to write a series of tutorials related to the functional nature of C#, and this one is going to be the first tutorial in this series.

Let's first talk about functional features in C#. All the elements in C# are not a part of Object-Oriented programming. As it is nature, C# contains multiple aspects. LINQ, delegates, method extensions, Tuples, local functions, immutability, and method chaining are the best examples of the functional features of C# language.

PS: To follow examples, go to our GitHub repo and download it.

Functional feature in C#

LINQ

LINQ stands for Language Integrated Query. It's a powerful set of technologies that allows you to query data directly within your C# code using a syntax that resembles SQL statements.

LINQ provides a consistent way to query various data sources, including in-memory collections (like lists or arrays), relational databases, and XML files. This simplifies development as you don't need to learn a different query language for each data source.

LINQ queries work with objects directly. This makes your code more readable and maintainable compared to traditional string-based queries.

LINQ extensively uses the idea of extension methods that rely on functional programming ideas.

// Define a list of accounts
            List<Account> accounts = new List<Account>()
                {
                    new Account { Name = "John Doe", City = "New York" },
                    new Account { Name = "Jane Doe", City = "Los Angeles" },
                    new Account { Name = "Alice Smith", City = "New York" },
                    new Account { Name = "Bob Smith", City = "Chicago" }
                };

            // Group accounts by city and count the number of accounts in each group
            var accountGroups = accounts.GroupBy(account => account.City)
                                         .Select(cityGroup => new { City = cityGroup.Key, Count = cityGroup.Count() });

            // Print the city and account count for each group
            foreach (var group in accountGroups)
            {
                Console.WriteLine($"City: {group.City}, Count: {group.Count}");
            }

Delegates

Delegates are a fundamental concept in C# that unlocks powerful features like event handling, callback methods, and more. Delegates are a type that acts as a reference to methods with a specific signature (parameter list and return type). Think of them as pointers to methods, but with more safety and object-oriented features compared to C++ function pointers. If you want even to simplify it, then just think about it as sending a method as an argument to another method.

If you want to learn more, here are my articles about it:

Well, let's switch to our simple example

 Func<decimal, decimal> multiply = x => x * 5;
            multiply(45);

Tuples

Tuples in C# are lightweight data structures that let you group a small number of related values together. They're useful in scenarios where you wouldn't want to create a full-fledged class to hold that data.

Introduced in C# 7.0, tuples provide a simple way to associate multiple values of potentially different data types.

Unlike arrays, tuples have a fixed size and order. You can access elements by their position (index) or by deconstructing the tuple into individual variables.

Tuples are easy to create and use without the need to define a class structure.

They can hold elements of different data types, making them adaptable for various use cases.

Methods can return tuples to provide more than one output value without resorting to out parameters or complex data structures.

static (string name, int age) GetUserInfo()
        {
            return ("John Doe", 30);
        }

 var userInfo = GetUserInfo();

Method Extensions

Method extensions are a powerful feature in C# that allows you to add new functionality to existing types without modifying the source code. This provides a clean and flexible way to extend the capabilities of classes, structures, and interfaces.

Method extensions are defined as static methods within a static class.

The first parameter of an extension method uses this keyword, followed by the type you're extending. This essentially treats the first parameter as if it were an instance method of that type.

When calling an extension method, you use the dot notation (.) on an instance of the extended type, followed by the extension method name and any required arguments.

Method extensions keep the original class or interface untouched, promoting cleaner separation of concerns and avoiding modification of existing code.

They allow you to add functionality to existing types without recompiling them. This is particularly useful for third-party libraries where you can't modify the source code.

Well-designed extension methods can improve code readability by adding functionality that logically belongs to the extended type.

You can define generic extension methods that work with multiple types, promoting code reuse.

namespace FunctionProgrammingIntro.Extensions
{
    public static class AccountListExtensions
    {
        public static IEnumerable<Account> ByCity(this IEnumerable<Account> accounts, string city)
        {
            return accounts.Where(x => x.City == city);
        }
    }
}

Local functions

Local functions, introduced in C# 7.0, are a powerful feature that allows you to define functions within other methods, constructors, or even other local functions. They offer several advantages.

Local functions encapsulate specific logic relevant to the outer function, keeping the main function focused and easier to understand.

We can break down Complex logic within a function into smaller, more manageable local functions, enhancing code readability.

If a specific piece of logic is used multiple times within a function, you can create a local function to avoid redundancy. This improves code maintainability and reduces the chance of errors if that logic needs modification.

Local functions can encapsulate helper logic that's only needed by the outer function. This keeps the main function's signature clean and avoids cluttering it with unnecessary details.

Local functions can be particularly useful for defining recursive algorithms. You can define the recursive logic as a local function within the main function, making the recursive calls and termination conditions clearer.

 int Multiply(int x, int y) => x * y;
            int result = Multiply(3, 4);

Immutability

The concept of immutability is widely used, especially nowadays in C# when you build apps based on Domain Driven Design(DDD)

Immutability in C# refers to the concept of designing objects or data structures that cannot be modified after their creation. While C# is primarily a mutable language, immutability offers several advantages and plays a significant role in various aspects of application development.

Immutable objects are inherently thread-safe because multiple threads can access the same object without the risk of data corruption caused by concurrent modifications. This is especially beneficial for multithreaded applications.

Once created, the state of an immutable object remains consistent, making its behavior more predictable and easier to reason about. This reduces the likelihood of errors caused by unexpected mutations.

Immutability often leads to simpler code, as you don't need to worry about complex logic to protect data from unintended modifications.

Immutable objects promote referential transparency, meaning if you call a function with the same arguments and an immutable object as input, you'll always get the same output. This makes functions easier to test and reason about.

When working with data that doesn't change, immutable objects can be efficiently cached and shared between different parts of your application without worrying about inconsistencies.

namespace FunctionProgrammingIntro
{
    public class Point
    {
        public  int X { get; } // Read-only property with init accessor
        public  int Y { get; } // Read-only property with init accessor

        public Point(int x, int y) // Constructor to initialize the readonly fields
        {
            X = x;
            Y = y;
        }

        // No setter methods defined for X and Y to prevent modifications

        // Optional methods for creating new instances with modifications:
        public Point MoveX(int deltaX) => new Point(X + deltaX, Y);
        public Point MoveY(int deltaY) => new Point(X, Y + deltaY);
    }
}

Method chaining

Method chaining is a programming technique commonly used in C# to improve code readability and maintainability. It involves calling multiple methods on the same object instance consecutively, with each method returning the same object type. This creates a chain-like structure where the output of one method becomes the input for the next.

namespace FunctionProgrammingIntro.Builder
{
    public class Computer
    {
        public string CPU { get; set; }
        public string RAM { get; set; }
        public string GPU { get; set; } // Optional component

        public Computer(string cpu, string ram, string gpu = null)
        {
            CPU = cpu;
            RAM = ram;
            GPU = gpu;
        }
        public override string ToString()
        {
            return $"CPU: {CPU}, RAM: {RAM}, GPU: {(GPU == null ? "Not included" : GPU)}";
        }
    }

    public interface IComputerBuilder
    {
        IComputerBuilder WithCPU(string cpu);
        IComputerBuilder WithRAM(string ram);
        IComputerBuilder WithGPU(string gpu); // Optional method
        Computer Build();
    }
    public class ComputerBuilder : IComputerBuilder
    {
        private string cpu;
        private string ram;
        private string gpu;

        public IComputerBuilder WithCPU(string cpu)
        {
            this.cpu = cpu;
            return this;
        }

        public IComputerBuilder WithRAM(string ram)
        {
            this.ram = ram;
            return this;
        }

        public IComputerBuilder WithGPU(string gpu)
        {
            this.gpu = gpu;
            return this;
        }

        public Computer Build()
        {
            return new Computer(cpu, ram, gpu);
        }

    }
}

Conclusion

To have a better understating of functional programming and even diving into details, it is better to understand the already implemented features using functional programming in C#. This tutorial provides a comprehensive guide to understanding the functional features of C#.