C# 9.0: Target-typed New Expressions – Make Your Initialization Code Less Verbose

Thomas Claudius Huber · September 8, 2020

C# 9.0: Target-typed New Expressions – Make Your Initialization Code Less Verbose

By Thomas Claudius Huber .NET, C# 24 Comments

In the previous blog posts you learned about different C# 9.0 features:

In this blog post, let’s look at another very interesting feature of C# 9.0 that is called target-typed new expressions.

Target-typed means that an expression gets the type from the context it is used in. With C# 9.0 the new expression gets the type from the context, which means you don’t have to specify the target-type explicitly to call a constructor. Let’s look at this with a simple example.

Creating New Objects Before C# 9.0

Let’s define the Friend class that you see in the code snippet below. As you can see, it has a default constructor and also a constructor with the parameters firstName and lastName to initialize the properties FirstName and LastName.

public class Friend
{
    public Friend() { }

    public Friend(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    public string FirstName { get; set; }
    public string LastName { get; set; }
}

To create a new instance of this Friend class, you can use this statement:

Friend friend = new Friend();

You can also use the constructor overload to pass in a firstname and a lastname:

Friend friend = new Friend("Thomas", "Huber");

As the variable gets initialized directly with a new Friend, you can also use the var keyword for the variable declaration like below. The C# compiler detects in this case the type Friend for the variable, as you assign a new Friend instance to it. The var keyword was introduced in 2007 with C# 3.0 and .NET Framework 3.5, and it works for local variables.

var friend = new Friend("Thomas", "Huber");

Now, in all those cases above you can see that the new expression – that’s the part on the right side of the = sign – always requires the class name. That’s not the case anymore with C# 9.0 if the target-type is already known from the left side of the = sign, which is always the case if you don’t use the var keyword on the left side of the = sign.

Use Your First Target-typed New Expression

With C# 9.0 you can create a new Friend like below with the target-typed new expression to call the default constructor. Note that I don’t specify the Friend class on the right side of the = sign, the compiler gets it from the left side of the = sign:

Friend friend = new();

You can also call the overloaded constructor of the Friend class by passing in a firstname and a lastname:

Friend friend = new("Thomas", "Huber");

But, of course, you can not use the target-typed new expression when you use the var keyword to declare your variable, because then the compiler does not have a chance to find out the type that you want to create. So, the following statement does not work:

var friend = new("Thomas", "Huber"); // does NOT work

What About Optional Constructor Parameters?

You could define the Friend class also with optional constructor parameters like below:

public class Friend
{
    public Friend(string firstName = null, string lastName = null)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Calling that constructor with the target-typed new expression works exactly the same way as you would call it with a classic new expression, you just omit the class name on the right side of the = sign. You could call the constructor for example without any arguments:

Friend friend = new();

You could call it with a firstname:

Friend friend = new("Thomas");

You could call it with firstname and lastname:

Friend friend = new("Thomas", "Huber");

You could also use named arguments to call it with just a lastname:

Friend friend = new(lastName: "Thomas");

So, everything works the same way as before, you just omit the type after the new keyword.

What’s the Point When You Can Use Var?

You might ask yourself what’s the point of target-typed new expressions when you can use the var keyword? What is the advantage of this:

Friend friend = new("Thomas", "Huber");

over this:

var friend = new Friend("Thomas", "Huber");

With the target-typed new expression you omit the type on the right side of the = sign, with the var keyword you omit the type on the left side of the = sign. For both statements above, the C# compiler produces exactly the same Intermediate Language code. So, it is your decision what you prefer. At least it is your decision for local variables, and so far we just talked about local variables.

Did you notice that the first code snippet in this section with the variable Friend friend could theoretically be a field of a class? The second code snippet could not be a field of a class, as fields do not support the var keyword. Fields are one example where target-typed new expressions are really powerful, because with fields you can not use the var keyword. And that’s the main point why and where you want to use target-typed new expressions:

You can use the var keyword only for local variables. That means target-typed new expressions are especially powerful to initialize properties and fields, because there the var keyword is not an option.

Let’s look at these cases where var is not an option in the next sections, because for all these cases target-typed new expressions make your code less verbose.

Initialize Properties With Target-typed New Expressions

Look at the class below. It’s a simple, but typical MainViewModel class that you could use in XAML-based apps, for example WPF or UWP/WinUI, when applying the Model-View-ViewModel pattern (MVVM). It has the properties AddFriendCommand and Friends, and both are initialized in the constructor with a classic new expression.

public class MainViewModel
{
    public MainViewModel()
    {
        AddFriendCommand = new DelegateCommand(AddFriendExecute);
        Friends = new ObservableCollection<Friend>();
    }

    public DelegateCommand AddFriendCommand { get; }

    public ObservableCollection<Friend> Friends { get; }

    private void AddFriendExecute()
    {
        Friends.Add(new Friend());
    }
}

You can change the code in the constructor to the code that you see below. As you can see, the class names for the initialization are not needed anymore.

Note that also the generic <Friend> argument for the ObservableCollection<Friend> is not needed with the target-typed new expression. So, you don’t write new<Friend>(), but just new().

public MainViewModel()
{
    AddFriendCommand = new(AddFriendExecute);
    Friends = new();
}

You could also initialize the Friends property directly like this – and if you ask me, yes, I think this is really beautiful code:

public ObservableCollection<Friend> Friends { get; } = new();

In addition to these adjustments, you can also create the new Friend object in the AddFriendExecute method with a target-typed new expression like this:

private void AddFriendExecute()
{
    Friends.Add(new());
}

With the changes applied, the MainViewModel class looks like this:

public class MainViewModel
{
    public MainViewModel()
    {
        AddFriendCommand = new(AddFriendExecute);
        Friends = new();
    }

    public DelegateCommand AddFriendCommand { get; }

    public ObservableCollection<Friend> Friends { get; }

    private void AddFriendExecute()
    {
        Friends.Add(new());
    }
}

Beside properties, another very useful case for target-typed new expressions are fields. Let’s look at fields in the next section.

Initialize Fields With Target-typed New Expressions

Below you see an ErrorViewModelBase class that contains some typical stuff that I created in several .NET projects. Note that the class is a simplified version that contains just enough to show you the power of target-typed new expressions. As you can see below, the class contains two new expressions. One to initialize the field _errorsByPropertyName, and another one to create a new List<string>.

public class ErrorViewModelBase
{
    protected readonly Dictionary<string, List<string>> _errorsByPropertyName
      = new Dictionary<string, List<string>>();

    public void AddError(string propertyName, string error)
    {
        if (!_errorsByPropertyName.ContainsKey(propertyName))
        {
            _errorsByPropertyName[propertyName] = new List<string>();
        }
        _errorsByPropertyName[propertyName].Add(error);
    }
}

With C# 9.0, you can replace those new expressions with target-typed new expressions like shown in the code snippet below. Especially the fact that you don’t have to write new Dictionary<string, List<string>>(), but just new() to initialize the field is very powerful. Dictionary<string, List<string>> is already used and visible in the field declaration, so why duplicate it with the initialization? A target-typed new expression helps you here to avoid that code duplication.

As mentioned, you can not use the var keyword for fields, so using var is not an option here for the _errorsByPropertyName field.

public class ErrorViewModelBase
{
    protected readonly Dictionary<string, List<string>> _errorsByPropertyName = new();

    public void AddError(string propertyName, string error)
    {
        if (!_errorsByPropertyName.ContainsKey(propertyName))
        {
            _errorsByPropertyName[propertyName] = new();
        }
        _errorsByPropertyName[propertyName].Add(error);
    }
}

Also the creation of a List<string> in the AddError method with just new() instead of new List<string>() is nice. With these changes, I think this class looks much cleaner and less verbose than before.

When to Use Target-typed New Expressions

There are many cases where I’ll definitely use target-typed new expressions without a thought. These are the cases where it is obvious to any programmer what new() will create. For example, look at this property declaration and initialization:

public ObservableCollection<Friend> Friends { get; } = new ObservableCollection<Friend>();

Here you can use a target-typed new expression without any thought, because it is totally clear from the property declaration that new() will create an ObservableCollection<Friend>:

public ObservableCollection<Friend> Friends { get; } = new();

But when you look at the constructor of the MainViewModel class in the code snippet below, you can not say what the target-typed new expressions create by just looking at the constructor:

public MainViewModel()
{
    AddFriendCommand = new(AddFriendExecute);
    Friends = new();
}

When reading the code, you need to look at the types of the properties AddFriendCommand and Friends to know what the two new expressions in the code snippet above are actually creating. But that’s only true if you do not read the code in a tool like Visual Studio, but in a simple text editor or on a blog like this one. If you look at the code in Visual Studio, you can hover any target-typed new expression with your mouse to see which constructor it calls. In the screenshot below I hovered the second new expression in Visual Studio and you can see in the tooltip that it actually creates an ObservableCollection<Friend>.

You can even navigate to the called constructor. In Visual Studio you do this by pressing F12 when the cursor is on the target-typed new expression. So, with this tooling support, the use of target-typed new expressions seems to be ok in any case.

Summary

You saw in this blog post different use cases for target-typed new expressions. I have to admit, I’m already a big fan of target-typed new expressions. Especially for direct field and property initialization where the var keyword is not an option, a target-typed new expression leads to much nicer code.

In the next blog post, you will learn more about the improved pattern matching in C# 9.0.

Happy coding,
Thomas