C# has been improved greatly over the years with useful features that have increased productivity for developers.
Below I’ll explain a few of my favorite features.
In many programming languages, writing a string with embedded variables can be cumbersome. The longer the string, the more noise is added affecting readability like so:
C# 6.0 introduced a new string interpolation feature in which the variables can be written as expressions without the need for awkward string concatenation:
This results in the same output, but the code is much easier to read and maintain. To use this feature the string must begin with the $ symbol . String formatters may also be applied as shown in the
As a plus – expressions will be highlighted within the whole string for better visibility in Visual Studio.
If you’ve created a few C# POCO classes over the years, I’m willing to bet many of the properties you’ve written are single read only statements.
Here’s a typical example where
FullNameis a read only property:
...And now here’s the same example using the
FullNameproperty as an expression-bodied function member:
The output is identical to the previous example. The code has been compacted down to one line, reducing noise.
Null checking is an important subject for producing stable apps. Until now, null checking has often been verbose. Here’s a typical null checking statement combined with a ternary operator:
With C# 6.0 null checking becomes more succinct:
In this example the variable
firstNameis assigned null if the person object is null. If the person object is not null, the value of the
FirstNameproperty will be applied. This works thanks to the
But what if we want to supply a substituted value for null values, similar to the ternary operator approach?
This can be solved by using the null coalescing operator:
Here, the expression always returns a string. The rules of the
?operator ensure that the left-hand side of the operator is evaluated only once.
Happy Coding 🤓