Avoid Null References

suggest change

C# developers get a lot of null reference exceptions to deal with. F# developers don’t because they have the Option type. An Option<> type (some prefer Maybe<> as a name) provides a Some and a None return type. It makes it explicit that a method may be about to return a null record.

For instance, you can’t read the following and know if you will have to deal with a null value.

var user = _repository.GetUser(id);

If you do know about the possible null you can introduce some boilerplate code to deal with it.

var username = user != null ? user.Name : string.Empty;

What if we have an Option<> returned instead?

Option<User> maybeUser = _repository.GetUser(id);

The code now makes it explicit that we may have a None record returned and the boilerplate code to check for Some or None is required:

var username = maybeUser.HasValue ? maybeUser.Value.Name : string.Empty;

The following method shows how to return an Option<>

public Option<User> GetUser(int id)
{
    var users = new List<User>
    {
        new User { Id = 1, Name = "Joe Bloggs" },
        new User { Id = 2, Name = "John Smith" }
    };

    var user = users.FirstOrDefault(user => user.Id == id);

    return user != null ? new Option<User>(user) : new Option<User>();
}

Here is a minimal implementation of Option<>.

public struct Option<T>
{
    private readonly T _value;

    public T Value
    {
        get
        {
            if (!HasValue)
                throw new InvalidOperationException();

            return _value;
        }
    }

    public bool HasValue
    {
        get { return _value != null; }
    }

    public Option(T value)
    {
        _value = value;
    }

    public static implicit operator Option<T>(T value)
    {
        return new Option<T>(value);
    }
}

To demonstrate the above avoidNull.csx can be run with the C# REPL.

As stated, this is a minimal implementation. A search for “Maybe” NuGet packages will turn up a number of good libraries.

Found a mistake? Have a question or improvement idea? Let me know.

Functional Programming:

* Func and Action

* Avoid Null References

* Higher-Order Functions

* Immutability

* Immutable collections

Table Of Contents

0 Getting Started With C#

1 Literals

2 Operators

3 Conditional Statements

4 Equality Operator

5 Equals and GetHashCode

6 Null-Coalescing Operator

7 Null-Conditional Operators

8 nameof Operator

9 Verbatim String

10 Common String Operations

11 String Format

12 String Concatenate

13 String Manipulation

14 String Interpolation

15 String Escape Sequences

16 StringBuilder

17 Regex

18 DateTime

19 Arrays

20 On Algorithm for circular rotation of an array

21 Enum

22 Tuples

23 Overview of C# collections

24 GUID

25 BigInteger

26 Collection Initializers

27 Looping

28 Iterators

29 IEnumerable

30 Value type vs Reference type

31 Built-in Types

32 Aliases of built-in types

33 Anonymous types

34 Dynamic type

35 Type Conversion

36 Casting

37 Nullable types

38 Constructors and Finalizers

39 Access Modifiers

40 Interfaces

41 Static Classes

42 Singleton Implementation

43 Dependency Injection

44 Partial class and methods

45 Object Initializers

46 Methods

47 Extension Methods

48 Named Arguments

49 Named And Optional Arguments

50 Data Annotation

51 Keywords

52 Recursion

53 Naming Conventions

54 XML Documentation Comments

55 Comments and regions

56 Inheritance

57 Generics

58 Using Statement

59 Using Directive

60 IDisposable interface

61 Reflection

62 IQueryable interface

63 LINQ to Objects

64 LINQ Queries

65 LINQ to XML

66 Parallel LINQ PLINQ

67 XmlDocument

68 XDocument

69 C# 7.0 Features

70 C# 6.0 Features

71 C# 5.0 Features

72 C# 4.0 Features

73 C# 3.0 Features

74 Exception Handling

75 NullReferenceException

76 Handling FormatException

77 Read and Understand Stack trackes

78 Diagnostics

79 Overflow

80 JSON handling

81 Using json.net

82 Lambda Expressions

83 Lambda expressions

84 Generic Lambda Query Builder

85 Properties

86 Initializing Properties

87 INotifyPropertyChanged interface

88 Events

89 Expression Trees

90 Overload Resolution

91 Preprocessor directives

92 Structs

93 Attributes

94 Delegates

95 File and Stream IO

96 Networking

97 Performing HTTP requests

98 Reading and writing .zip files

99 FileSystemWatcher

100 Asynchronous Socket

101 Action Filters

102 Polymorphism

103 Immutability

104 Indexer

105 Checked and Unchecked

106 Stream

107 Timers

108 Stopwatches

109 Threading

110 Async/Await, BackgroundWorker, Task and Thread examples

111 Async Await

112 Synchronization Context in Async/Await

113 BackgroundWorker

114 Task Parallel Library

115 Making a variable thread safe

116 Lock Statement

117 Yield Keyword

118 Task Parallel Library TPL Dataflow Constructs

119 Functional Programming

120 Func delegates

121 Function with multiple return values

122 Binary Serialization

123 ICloneable

124 IComparable

125 Accessing Databases

126 Using SQLite

127 Caching

128 Code Contracts

129 Code Contracts and Assertions

130 Structural Design Patterns

131 Creational Design Patterns

132 Implementing Decorating Design Pattern

133 Implementing Flyweight Design Pattern

134 System.Management.Automation

135 Pointers

136 Pointers and Unsafe Code

137 Simulating C Unions with C# Structs

138 Reactive Extensions Rx

139 AsseblyInfo.cs examples

140 Creating Console Application

141 CLSCompliantAttribute

142 ObservableCollection

143 Hash Functions

144 Generating Random Numbers

145 Cryptography

146 Unsafe Code in .NET

147 C# Script

148 Runtime Compile

149 Interoperability

150 .NET Compiler Platform Roslyn

151 Creating Own MessageBox in Windows Form Application

152 Including Font Resources

153 Garbage Collector

154 Windows Communication Foundation

155 Contributors