book

Functional Programming with C#

Name: Functional Programming with C#
Author: Alex Yagur
ISBN: 9781805122685

by Alex Yagur

July 2024

Beginner to intermediate

258 pages

5h 11m

English

Packt Publishing

Read now

Unlock full access

Functional Programming with C#
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Part 1:Foundations of Functional Programming in C#
Chapter 1: Getting Started with Functional Programming
Functional versus imperative versus object-oriented programmingImperative programmingObject-oriented programmingFunctional programmingBlending paradigmsHow functional programming is supported in C#How to write functional code in C#A practical example – a book publishing systemHow to combine functional and object-oriented paradigmsMeet Steve and JuliaSummary
Chapter 2: Expressions and Statements
Task 1 – Name and count all expressions and all statementsTask 2 – Use expressions instead of statementsTask 3 – Create an expression treeUnderstanding the difference between expressions and statementsExample of expressionsExample of statementsKey differences between expressions and statementsGuided exercise – finding expressions and statements in sample codeHow to use expressions for clear and simple codeThe power of expressions – improving readability and maintainabilityTechniques to convert statements to expressionsGuided exercise – refactoring code using expressionsLambda expressions, expression-bodied members, and anonymous methodsWhat are lambda expressions?Multiple parameters in lambda expressionsLambda expressions evolutionUnderstanding anonymous methodsHow do anonymous methods work?When to use anonymous methodsPractical examples – applying these features in real codeExpression-bodied membersExercise – implementing lambda expressions and anonymous methodsExpression trees and how to use them to manipulate expressions at runtimeBuilding and manipulating expression treesCreating and manipulating complex expression treesQuerying data with expression trees – LINQ and beyondGuided exercise – constructing and manipulating expression treesProblem sets and exercisesExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 3: Pure Functions and Side Effects
Task 1 – Refactoring to a pure functionTask 2 – Isolating side effectsTask 3 – Using a Pure attributeUnderstanding pure functionsExamples of pure functionsThe benefits of pure functionsComparisons of pure functions and non-pure functionsSide effectsCommon sources of side effectsConsequences of side effectsStrategies to minimize side effectsFavor immutabilityUse readonly and constUse functional programming principlesEncapsulate side effectsMarking pure functions with the Pure attributeUnderstanding the Pure attribute in C#The benefits of marking functions as pureCaveats and considerations when using the Pure attributeExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 4: Honest Functions, Null, and Option
Task 1 – Refactor for honest return typesTask 2 – Guard against null inputsTask 3 – Pattern matching with nullable typesHonest functions – definition and understandingThe problems with hidden nullsA quick look back – C# and nullCommon mistakes and the troubling NullReferenceExceptionNot all bad – the value of nullEmbracing honesty with nullable reference typesWhat are nullable reference types?Transitioning to NRTsEnabling nullable reference typesDisabling nullable reference typesWarnings and annotations optionsThe bigger picture – project-wide settingsReturning with intentionThe distinction between UserProfile and UserProfile?Honoring a function’s contractDemanding honesty from function inputsNullable reference types to the rescueUsing preconditions and contractsUsing built-in checksThe power of explicit non-null inputsPattern matching and nullable typesPattern matching with nullable typesSwitch expressions with property patternsEnsuring clarity with nullable typesThe null object patternThe problem with null checksThe null object solutionAdvantagesLimitations and considerationsBeyond null – using OptionA brief introduction to OptionAdvantages of the Option type over nullable typesThe interplay of Option and nullable typesPractical scenarios – handling nulls effectivelyCase study – managing YouTube videosCase study – managing different video typesCase study – working with non-existing objectsThe impact of handling nulls in real-world scenariosThe reality of honesty in C# – why there will never be truly honest functionsThe compromises of the C# language designPractical tips and best practicesStrategies for migrating existing code bases to adopt nullable reference types and OptionCommon pitfalls and how to navigate themTesting strategies for null and Option handlingExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Part 2:Advanced Functional Techniques
Chapter 5: Error Handling
Task 1 – Custom error types and result usageTask 2 – Utilizing ROP for validation and processingTask 3 – Implementing a Retry mechanism using functional techniquesTraditional error handling in C#try-catch blocksExceptionsThe Result typeImplementing the Result typeUsing the Result typeRailway-Oriented Programming (ROP)The essence of BindChaining operations with BindComposable error handling with ROPHandling diverse error typesBenefits of isolationExtending ROP for asynchronous operationsDesigning your own error-handling mechanismsUse factory methods for creationExtend with BindCustomize error typesLeverage extension methodsIntegration with existing codeAlways iterate and refinePractical tips for functional error handlingAvoid null with optionsLogging errorsTwo strategies To replace exceptionsAnticipate errors – make it predictableEmbrace compositionEducate your teamTraditional versus functional error handling comparisonThe traditional wayThe functional wayComparative analysisMaking the shiftPatterns and anti-patterns in functional error handlingExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 6: Higher-Order Functions and Delegates
Task 1 – Sorting functionTask 2 – Customized calculationsTask 3 – ComparisonUnderstanding higher-order functionsThe power of higher-order functions in functional programmingCreating versatile code with fewer errorsSupporting a more declarative coding styleDelegates, actions, funcs, and predicatesDelegatesActionsFuncsPredicatesCallbacks, events, and anonymous methodsThe role of delegates in eventsDelegates and anonymous methodsHarnessing LINQ methods as higher-order functionsFilteringData transformationData aggregationCase study – putting it all togetherStep-by-step walk-through and analysis of the codeBest practices and common pitfallsExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary

Chapter 7: Functors and Monads
Task 1 – Functor usageTask 2 – Applicative functorTask 3 – Monad usageWhat’s a functor?Identity lawComposition lawCreating our own functorFunctor benefitsApplicative functorsThe Apply method implementationApplicative functor lawsMonadsThe Bind methodMonad lawsUtilizing monadsKey takeawaysExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Part 3:Practical Functional Programming
Chapter 8: Recursion and Tail Calls
Task 1 – Recursive enemy countTask 2 – Wave generationTask 3 – Asynchronously updating enemy statsIntroducing recursionRecursive thinkingTypes of recursionSimple recursionTail recursionChallenges of recursionStack overflow riskDefault stack size and limitationsPerformance considerationsLeveraging C# features for recursionLocal functionsPattern matchingAdvanced recursive patternsMutual recursionMemoizationComparison with iterative solutionsReadabilityPerformanceRecursion in asynchronous programmingExplaining asynchronous recursion under the hoodSynchronous versus asynchronous recursionScenarios for asynchronous recursionExercisesExercise 1Exercise 2Exercise 3SolutionsExercise 1Exercise 2Exercise 3Summary
Chapter 9: Currying and Partial Application
Task 1 – Currying tower attack functionsTask 2 – Partial application for game settingsTask 3 – Currying permission checks for game featuresUnderstanding curryingStandard approachCurried approachStep-by-step implementation of curryingUse casesConfiguration settingsEvent handlingPartial applicationAsynchronous programmingPartial applicationAreas for partial applicationExample of partially applying a function for configuration settingsStandard rendering functionPartially applied functionChallenges and limitationsExercisesExercise 1Exercise 2Exercise 3SolutionsSolution 1Solution 2Solution 3Summary
Chapter 10: Pipelines and Composition
Task 1 – Enemy wave processing pipelineTask 2 – Game data file processingTask 3 – Dynamic SQL query generation using currying and partial applicationFunction compositionBuilding pipelinesPerformance considerationsThe fluent interfaceAdvanced composition with monadsExercisesExercise 1Exercise 2Exercise 3SolutionsSolution 1Solution 2Solution 3Summary
Part 4:Conclusion and Future Directions
Chapter 11: Reflecting and Looking Ahead
A summary of the main concepts and techniquesComparison with other languagesResources for further learningClosing thoughts
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Overview

Explore the power of functional programming in C# with 'Functional Programming with C#.' This book takes you step-by-step through concepts like pure functions, recursion, and higher-order functions, enabling you to write cleaner, reusable, and more maintainable code. Simplify error handling and manage concurrency effectively for real-world applications.

What this Book will help me do

Understand the fundamentals of functional programming in the context of C#
Learn to write modular and maintainable code with higher-order functions and composition
Handle errors and asynchronous operations using functional approaches
Explore advanced techniques like recursion and memoization for robust coding
Apply functional programming paradigms to solve real-world programming challenges

Author(s)

Alex Yagur is an experienced software developer specializing in C# programming and functional paradigms. With years of hands-on development experience, Alex has a passion for teaching and simplifying complex programming concepts. This book reflects his commitment to sharing effective coding practices and enabling programmers to elevate their skills.

Who is it for?

This book is suitable for C# developers with intermediate experience who want to expand their skill set by understanding and applying functional programming techniques. Programmers already familiar with object-oriented design, seeking to explore new approaches that enhance code quality, will greatly benefit. Beginners with a solid grasp of programming basics can also follow along due to its clear and structured content. This book is perfect for those aiming to create robust, flexible, and maintainable software solutions using C#.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781805122685

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills