C# 9.0 Features

In this blog you will learn about C# 9.0 and .NET were released on dotNET Conference 2020.

C# 9.0 was released with .NET 5.0. These two were released simultaneously in .NET Conf 2020.

 

Today we are going to discuss three features from C# 9.0. In order to use C# 9.0 and .NET 5.0, we should have Visual Studio 16.8 or above. As you might have already know .NET is the next version from .NET Core 3.1. The reason .NET 5.0 was chosen so that there is no confusion with the .NET version 4.* and Microsoft wanted to get rid of the Core because going forward this is the .NET version. Though for ASP.NET it is going to be still named as ASP.NET Core 5 because there is already AP.NET MVC 5.0. Here to avoid confusion, Core is retained. Same is applicable for Entity Framework Core. Entity Framework 5.0 will be named as Entity Framework Core 5 because there is already EF 5.0 and EF 6.0. Let us dive into features.

 

Init Only setters

 

Using the getter and setter we can create mutable objects, meaning after creating objects, we can keep changing the value of the properties associated with objects.

 

Assume that we have a class as below,

public class WeatherForecast {
    public DateTime Date {
        get;
        set;
    }
    public int TemperatureC {
        get;
        set;
    }
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
    public string Summary {
        get;
        set;
    }
}

The below code snippet will explain the mutable object.

public IEnumerable < WeatherForecast > Get() {
    var rng = new Random();
    return Enumerable.Range(1, 5).Select(index => {
        var weather = new WeatherForecast {
            Date = DateTime.Now.AddDays(index),
                TemperatureC = rng.Next(-20, 55),
                Summary = Summaries[rng.Next(Summaries.Length)]
        };
        //the object weather is mutable.
        //here we can assign a new value to the property Summary.
        weather.Summary = "Changing the initial value.";
        return weather;
    }).ToArray();
}

If we want to make this object immutable, let us see how “init” keyword can be leveraged in C# 9.0. Instead of “set”, we are going to use “init” in WeatherForecast model.

public class WeatherForecast {
    public DateTime Date {
        get;
        init;
    }
    public int TemperatureC {
        get;
        init;
    }
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
    public string Summary {
        get;
        init;
    }
}

What the “init” does is, it allows you to set the properties during the first time the object is created. So when you are creating the weatherforecast object, if you have inline declaration of the properties, it is going to allow you to assign. But after that, it will not allow you to assign any new values.

public IEnumerable < WeatherForecast > Get() {
    var rng = new Random();
    return Enumerable.Range(1, 5).Select(index => {
        var weather = new WeatherForecast {
            Date = DateTime.Now.AddDays(index),
                TemperatureC = rng.Next(-20, 55),
                Summary = Summaries[rng.Next(Summaries.Length)]
        };
        //the object weather is immutable.
        //here we can't assign a new value to the property Summary.
        //this is a compile time error
        weather.Summary = "Changing the initial value.";
        return weather;
    }).ToArray();
}

The init setter allow you to assign a value during the object initialization. This is extremely convenient feature which can get rid of lot of boiler plate code – declaring constructor and setting everything up in constructor.

 

Now let us get into next feature.

 

Record Type

 

Let us use the same WeatherForecast mode, but instead of “class” keyword, we will be using “record”

public record WeatherForecast(DateTime Date, int TemperatureC, string Summary) {
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

Here is a biggest advantage – we got rid of all the boiler plate code.

 

Let us take a look at the object initialization.

public IEnumerable < WeatherForecast > Get() {
    var rng = new Random();
    return Enumerable.Range(1, 5).Select(index => {
        var weather = new WeatherForecast(DateTime.Now.AddDays(index), rng.Next(-20, 55), Summaries[rng.Next(Summaries.Length)]);
        //the object weather is immutable.
        //here we can't assign a new value to the propery Summary.
        //this is a compile time error.
        //by default record setter is init only
        weather.Summary = "Changing the initial value.";
        return weather;
    }).ToArray();
}

Another important feature comes with record type which is “with” expression.

 

Usage

public IEnumerable < WeatherForecast > Get() {
    var rng = new Random();
    return Enumerable.Range(1, 5).Select(index => {
        var weather = new WeatherForecast(DateTime.Now.AddDays(index), rng.Next(-20, 55), Summaries[rng.Next(Summaries.Length)]);
        var newWeather = weather with {
            TemperatureC = 25
        };
        //Here Summary will be same as from the previous object,
        //only TemperatureC will be changed
        Console.WriteLine($ "New Summary Value = {newWeather.Summary}");
        return weather;
    }).ToArray();
}

Here using “with” keyword, a new object will be created from the base and can be modify some of the properties.

 

The last but not the least feature

 

Top level statements

 

Top level code or statements are nothing but the code available in Program.cs as below 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace dotNET5 {
    public class Program {
        public static void Main(string[] args) {
            CreateHostBuilder(args).Build().Run();
        }
        public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args).ConfigureWebHostDefaults(webBuilder => {
            webBuilder.UseStartup < Startup > ();
        });
    }
}

We can get rid of the entire code and keep a simple line as below- this will get compiled and can see the “Hello World” on the output window. Try this code at your end and see.

System.Console.WriteLine("Hello World");

Honestly speaking, this is not useful as this is not what we are going to do in real life programming.

 

Let us modify the Program.cs class file as below and execute.

using dotNET5;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
CreateHostBuilder(args).Build().Run();
static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args).ConfigureWebHostDefaults(webBuilder => {
    webBuilder.UseStartup < Startup > ();
});

It behave exactly same as before. When this is helpful? In my opinion, this will be helpful when you are writing server less functions- for example, if you are using Azure functions or AWS Lambda, this kind of code is going to be very helpful.

 

That’s all I wanted to cover in this session. Thanks for reading my article. I appreciate your feedback in the comment section below.