Learn Railway Orientated Programming In C#

1. Railway Orientated
Programming
C# Edition
Tama Waddell

3.  No Functional Programming experience is
required
 Experience in C# or other Object Oriented
languages helps
 Basic understanding of Trains
Prerequisites

4. Set the scene
 Working on a team at AGL
 Discussions about code cleanliness comes up
regularly
 Wanted to help out
 This is the story

5. The Problem

6. Example project
 Top up MyKi
 An API
 Example Only
 Credit card only
payment

7. Happy Path
1.Validate request
2.Charge the credit card
3.Update balance
4.Return receipt

8. Sad Path
 Increases the size of
the code
 Makes it less
readable
 Losing the domain of
the code

9. ModelView Controller
 Model View Controller (MVC)
first used at Xerox in the 1970s
 Popularised on the web thanks
to Ruby on Rails.
 Fat Controller and Fat Model
problem

10. The Service Layer
 Enterprise Application
Architectures by Martin
Fowlers
 Manipulate the model
 Can the controller show us
the flow

11. The God Object
 MVC
 Service layer
 MVVM
 CQS
 Serverless

12. Goals
 Happy Path code without sacrificing error
checking
 Remove the God Object and compose smaller
functions
 Make the controller show the data flow
 Introduce some Functional Programming
concepts
 Learn something new and have fun!

13. A Functional Approach

14. C# and Functional
Programming
 Lambda expressions
 LINQ
 Better tuple support,
 Pattern matching
 Read only collections
 Local functions
 etc

15. Functional ApproachTo Error
Handling Scott Wlashin
https://fsharpforfunandprofit.com/rop
 Marcus Denny from ALT.NET
 Vladimir Khorikov – Microsoft MVP from
Washington DC
 https://enterprisecraftsmanship.com
 The railway is the analogy
 Happy path programming

16. Introducing ROP
 Result
 Error
 Tracks (success, fail)
 Functions (execute)
 Switches (join tracks)
Success
Input
Failure
Function

17. Result

18. Result
 Holds either success or
failure
 Can hold errors on failure
 Holds a value on success
 Is immutable
 Recreated on each call
 Can transform the type
Success Failure
Input

19. F# Results
 Native support F# 4.1 (early 2017)
 https://docs.microsoft.com/en-
us/dotnet/fsharp/language-
reference/results
 Has Error and Ok as keywords
 Can we do this in C# ?

20. C# Result
 Immutable
 Private constructors
 Constructs either
Success or Fail

21. Error

22. ErrorType
 Store all the business
errors in an enumeration
 Forces you to handle all
errors
 Keeps all the errors
together
 Could be a big ugly in
size

23. Exceptions
 Exceptions are for
exceptional
circumstances
 Don’t use for control
flow
 Good use for I/O errors

24. Tracks

25. SingleTrack Function
 Single track function is just
a function which returns a
value
Input
Output

26. TwoTrack Function
Success
Input
Failure
 Two track function is a
function which returns a
result type

27. Dead End Function Input
 Dead End function is a
function which doesn't
return anything

28. Supervisory
 Both tracks
 E.g. Logging, metrics
Success Failure
Success Failure

29. Switches

30. Switches
 Constructors Create a new track
 Adapters Convert one kind of track into
another
 Combiners Joining many tracks

31. Bind
 Adapter Block
 Two-Track in, Two-Track out
 Only executes on the
Success Track
Success Failure
Success
Function
Failure

32. Map
 Adapter Block
 One-Track in, Two-Track out
 Only executes on the
Success Track
Success Failure
Success Failure

33. DoubleMap
 Supervisory functions
 Executes on both Tracks
Success Failure
Success Failure

34. Tee
 Adapter Block
 Takes a dead-end function
 Turns it into a one-track
Success
Success

35. Succeed
Success Failure
 A Constructor
 Always on the Success Track
 One-Track, Two-Track
Input

36. Fail
FailureSuccess
 A Constructor
 One-Track, Two-Track
 Always on the Failure Track
Input

37. Lift Example 1
 Exception handling
 One-Track, Two-Track
FailureSuccess
Success

38. Lift Example 2
 Boolean to result
 One-Track, Two-Track
FailureSuccess
Success

39. Handle Success Failure
Output

40. In Action

41.  New methods for this
example
 Bind two Two-Track
functions
 Validate the Amount
 Validate the Account
Number
Validation

42. Validation Cont.
Validate
Amount
Validate
Account
Failure
Input
 Two-Track function
 Join them together with
Bind

43. Credit Card Charge
 Exception Handling
 Single-Track to Two-Track within
the function
Charge
Credit Card
Validate
Amount
Success Failure

44. Update Card
Charge
Credit Card
Success Failure
Update
Card
 Dead End Function
 Tee

45. Log
 DoubleMap Update
Card
Log

46. Return Receipt
 Map
Log
Success Failure
Make
Response

47. Bonus!
 OnSuccess
 OnFailure
 OnBoth
 SucceedWith
 FailWith

48. Bringing It AllTogether
Handle
Output
Validate
Account
Input
Validate
Amount
Charge
Credit Card Update Card
Log Make
Response

49. Evaluation

50. Developer Feedback
 Liked the reduced nesting
 Was more readable
 Service layer broken down into reusable parts
 Is showing dataflow better
 Bit of a learning curve
 Bit difficult to debug
 Preferred the OnSuccess/OnFailure over Map,
Bind

51.  State machines
 Validation
 Business logic
 Lambdas/ Azure Functions
Good Use Cases

52.  Code shows the Happy Path without sacrificing
error checking
 Compose smaller reusable functions
 The controller shows the data flow
 Learned some minor Functional Programming
concepts
 And have fun!
Recap Goals

53. Advance

54. Async/Await
 Task to overlap result
 Needs combinations of accepted and
return

55. CQS
 Command Query Separation
 Command returns the result
type
 Query should be Single Track

56. Azure Functions / AWS
Lamdas Single page please
 Show the flow at the top of
the page
 Keep it simple

57. Resources
 https://www.pluralsight.com/courses/csharp-
applying-functional-principles
 https://fsharpforfunandprofit.com/rop/

58. Thank you!

59. Questions?