When you only want to iterate over a subset of a collection, you may use linq to objects to query it, or helper methods that return an IEnumerable instance that contain only the object subset.

If a method returns an IEnumerable, it can return multiple objects by using the yield return statement.

Lets’s look at an Example:

1
2
4
6
8
10

The second example returns a filtered List of objects:

Dan: 20
Mitchell: 25

And yes, the same result can be archived with an simple linq statement:

persons
.Where( person => person.Age >= 18 )
.ToList()
.ForEach( person => Console.WriteLine(person) );

If you’re interested how the C# compiler handles this, have a look at John Skeet’s article “Iterator block implementation details: auto-generated state machines“.

There are cases, when the null object pattern may reduce null checks, but there still remain many places in your code where you have to implement them.

Let’s have a look at two C# features for null checking.

Null coalesce operator

When you handle variables that may be null, you often have to check if they are null and if they are, use a default value.
To make this task as simple as possible C# has the null coalescing operator ??, which works similar to a ternary / conditional operator with an == null condition.

NULL conditional OPERATORs (C# 6)

The two new operators ?. and ?[ make null checking easier and eliminate boilerplate code. The ? means that the element on the right is only accessed when it’s not null. ?. is used for references and ?[ for arrays.

Let’s look at an example:

Conclusion

Our code should be as simple and as expressive as possible. C# has 2 convenient features that help us to archive this goal.

I definitely recommend to try this features to see yourself how this cleans your code- for example LINQ, EF, WebRequests and so on.

It’s recommended to use properties instead, wich have get and set “accessors”. From the outside the properties are accessed like fields, but the compiler generates hidden methods.

For example 2 the compiler creates a hidden backing field which is used for the get and set accessors (C# 3). Without the boilerplate code it’s simple and clean.

In the VS editor you can type prop and use the template, press tab to jump between the type and name.

Properties can be initialized and it’s also possible to make them immutable (C#), which makes them thread-safe and predictable:

Output:
40
10

Conclusion
Properties are simple and powerful and should be used to expose data. The encapsulation has also positive side effects, like being able to log changes or to break in the get and set accessors with the debugger.

There are exceptions when accessing a field directly may be a better. For example extremely memory and performance optimized code (graphics, etc). But normally the minimal overhead is negligible.

Example project
Heres’s an example project that uses different types of properties (and it’s test project).

Over the years this became a challenge in development, working with multiple threads and the GUI in parallel isn’t that easy.

Since C# 5 the async and await keywords are available, which abstract this complex problem.
You call a method which has the async keyword in it’s definition. The call returns immediately, you can alter the GUI or do other stuff in parallel. At the point when you finally need the results, you use the await keyword.

Here’s an example:

The WoisLookup class provides the async methods:

And this is the result:

The full project is available in my Github repository.

MSDN: Asynchronous Programming with Async and Await (C# and Visual Basic)