Author: Vladimir Khorikov www.eastbanctech.com With the advent of LINQ, C# has gotten a significant exposure to functional programming. However, functional programming in C# is not restricted to the use of extension methods, lambdas and immutable classes. There are a lot of practices that haven't been adopted as widely because there's not much of native language support for them in C#. Still, they can be extremely beneficial should you incorporate them into your day-to-day work. From this presentation you’ll learn: • The fundamental principles behind functional programming, • Why they are important, • How to apply them in practice.

1. Functional Programming in C#

2. What is Functional Programming?
• Side-effect free programming?
• Higher order functions?
• Use of a functional language like F# / Haskell / Scala?

3. Functional programming is
programming with mathematical
functions.

4. Problem solved!

5. What is Functional Programming?
Mathematical
function
Class
method=

6. What is Functional Programming?
f
Referential transparency:
same input – same result
Information about possible
inputs and outcomes

7. What is Functional Programming?
public double Calculate(double x, double y)
{
return x * x + y * y;
}
public long TicksElapsedFrom(int year)
{
DateTime now = DateTime.Now;
DateTime then = new DateTime(year, 1, 1);
return (now - then).Ticks;
}
Same input – same result Result is always different

8. What is Functional Programming?
public static int Divide(int x, int y)
{
return x / y;
}
f
Integer
Integer
Integer
1
0
?
DivideByZeroException

9. Method Signature Honesty
Method
signature
All possible
inputs
All possible
outcomes

10. Method Signature Honesty
Honest signatureDishonest signature
public static int Divide(int x, int y)
{
return x / y;
}
public static int Divide(int x, NonZeroInteger y)
{
return x / y.Value;
}
public static int? Divide(int x, int y)
{
if (y == 0)
return null;
return x / y;
}

11. Mathematical Function
• Honest
• Has precisely defined input and output
• Referentially transparent
• Doesn’t affect or refer to the global state

12. Why Functional Programming?
Composable
Easy to reason about
Easier to unit test
Reducing
complexity

13. Immutability
• Immutability
• Inability to change data
• State
• Data that changes over time
• Side effect
• A change that is made to some state

14. Immutability
Mutable
operations
Dishonest
code=

15. Immutability
fInput Output
Side effect
Method
signature
Hidden part

16. Immutability
fInput
Output
Side effect
Method
signature
Hidden part
Output 2

17. Why Does Immutability Matter?
• Increased readability
• A single place for validating invariants
• Automatic thread safety

18. How to Deal with Side Effects
Command–query separation principle
Command Query
Produces side effects Side-effect free
Returns void Returns non-void

19. How to Deal with Side Effects
public class CustomerService {
public void Process(string customerName, string addressString) {
Address address = CreateAddress(addressString);
Customer customer = CreateCustomer(customerName, address);
SaveCustomer(customer);
}
private Address CreateAddress(string addressString) {
return new Address(addressString);
}
private Customer CreateCustomer(string name, Address address) {
return new Customer(name, address);
}
private void SaveCustomer(Customer customer) {
var repository = new Repository();
repository.Save(customer);
}
}
Command
Query
Command
Query

20. How to Deal with Side Effects
var stack = new Stack<string>();
stack.Push("value"); // Command
string value = stack.Pop(); // Both query and command

21. How to Deal with Side Effects
Application
Domain logic Mutating state
Generates artifacts
Uses artifacts to change
the system’s state

22. How to Deal with Side Effects
Immutable CoreInput Artifacts
Mutable Shell

23. Exceptions and Readability
public ActionResult CreateEmployee(string name) {
try {
ValidateName(name);
// Rest of the method
return View("Success");
}
catch (ValidationException ex) {
return View("Error", ex.Message);
}
}
private void ValidateName(string name) {
if (string.IsNullOrWhiteSpace(name))
throw new ValidationException("Name cannot be empty");
if (name.Length > 100)
throw new ValidationException("Name is too long");
}

24. Exceptions and Readability
public Employee CreateEmployee(string name)
{
ValidateName(name);
// Rest of the method
}

25. Exceptions and Readability
Exceptions for
flow control
Goto
statements=

26. Exceptions and Readability
Method with
exceptions
Mathematical
function=

27. Exceptions and Readability
fInput Output
Exceptions
Method
signature
Hidden part

28. Always prefer return values
over exceptions.

29. Use Cases for Exceptions
• Exceptions are for exceptional situations
• Exceptions should signalize a bug
• Don’t use exceptions in situations you expect to happen

30. Use Cases for Exceptions
Validations
Exceptional
situation=

31. Primitive Obsession
Primitive obsession stands for
using primitive types for
domain modeling.

32. Drawbacks of Primitive Obsession
public class User
{
public string Email { get; }
public User(string email)
{
Email = email;
}
}

33. public class User
{
public string Email { get; }
public User(string email)
{
if (string.IsNullOrWhiteSpace(email))
throw new ArgumentException("Email should not be empty");
email = email.Trim();
if (email.Length > 256)
throw new ArgumentException("Email is too long");
if (!email.Contains("@"))
throw new ArgumentException("Email is invalid");
Email = email;
}
}
Drawbacks of Primitive Obsession

34. Drawbacks of Primitive Obsession
public class Organization
{
public string PrimaryEmail { get; }
public Organization(string primaryEmail)
{
PrimaryEmail = primaryEmail;
}
}

35. public class Organization
{
public string PrimaryEmail { get; }
public Organization(string primaryEmail)
{
if (string.IsNullOrWhiteSpace(primaryEmail))
throw new ArgumentException("Email should not be empty");
primaryEmail = primaryEmail.Trim();
if (primaryEmail.Length > 256)
throw new ArgumentException("Email is too long");
if (!primaryEmail.Contains("@"))
throw new ArgumentException("Email is invalid");
PrimaryEmail = primaryEmail;
}
}
Drawbacks of Primitive Obsession

36. Drawbacks of Primitive Obsession
Dishonest signature
public class UserFactory
{
public User CreateUser(string email)
{
return new User(email);
}
}
public int Divide(int x, int y)
{
return x / y;
}
fstring user
Dishonest signature

37. Drawbacks of Primitive Obsession
Makes code
dishonest
Violates the
DRY principle

38. Wrap primitive types with
separate classes

39. Drawbacks of Primitive Obsession
public class UserFactory
{
public User CreateUser(Email email)
{
return new User(email);
}
}
public int Divide(int x, NonZeroInteger y)
{
return x / y;
}
femail user
Honest signature Honest signature

40. Getting Rid of Primitive Obsession
• Removing duplications
• Method signature honesty
• Stronger type system

41. The Billion-dollar Mistake
string someString = null;
Customer customer = null;
Employee employee = null;

42. The Billion-dollar Mistake
“I call it my billion-dollar mistake. It has caused
a billion dollars of pain and damage in the last
forty years.”
Tony Hoare

43. The Billion-dollar Mistake
public class Organization
{
public Employee GetEmployee(string name)
{
/* ... */
}
}
public class OrganizationRepository
{
public Organization GetById(int id)
{
/* ... */
}
}

44. The Billion-dollar Mistake
public class MyClassOrNull
{
// either null
public readonly Null Null;
// or actually a MyClass instance
public readonly MyClass MyClass;
}
public class MyClass
{
}

45. The Billion-dollar Mistake
fInteger MyClass
MyClassOrNull
Dishonest

46. Mitigating the Billion-dollar Mistake
Maybe<T>

47. Mitigating the Billion-dollar Mistake
public class OrganizationRepository
{
public Organization GetById(int id)
{
/* ... */
}
}
Maybe<Organization>

48. Mitigating the Billion-dollar Mistake
public class OrganizationRepository
{
public Maybe<Organization> GetById(int id)
{
/* ... */
}
}
public class Organization
{
public Employee GetEmployee(string name)
{
/* ... */
}
}

49. Mitigating the Billion-dollar Mistake
public class OrganizationRepository
{
public Maybe<Organization> GetById(int id)
{
/* ... */
}
}
public static int? Divide(int x, int y)
{
if (y == 0)
return null;
return x / y;
}
Honest
Honest

50. Functional C#
Demo time

51. Summary
• Functional programming is programming with mathematical functions
• Method signature honesty
• Referential transparency
• Side effects and exceptions make your code dishonest about the
outcome it may produce
• Primitive obsession makes your code dishonest about its input parts
• Nulls make your code dishonest about both its inputs and outputs
• Applying Functional Principles in C# Pluralsight course:
https://app.pluralsight.com/courses/csharp-applying-functional-
principles

52. THANK YOU
Vladimir Khorikov
@vkhorikov
vkhorikov@eastbanctech.com
202-295-3000
eastbanctech.com