It is a good practice to use a default fallback language most people will understand, in case a translation is not available. I suggest to use English as default fallback language.

Recursive interpolation

Although not very useful, it is allowed to use an interpolated string recursively inside another's curly brackets:

Console.WriteLine($"String has {$"My class is called {nameof(MyClass)}.".Length} chars:"); Console.WriteLine($"My class is called {nameof(MyClass)}.");

Output:

String has 27 chars:

My class is called MyClass.

Section 72.3: Auto-property initializers

Introduction

Properties can be initialized with the = operator after the closing }. The Coordinate class below shows the available options for initializing a property:

Version ≥ 6.0

public class Coordinate

{

public int X { get; set; } = 34; // get or set auto-property with initializer

public int Y { get; } = 89; // read-only auto-property with initializer

}

Accessors With Di erent Visibility

You can initialize auto-properties that have di erent visibility on their accessors. Here’s an example with a protected setter:

public string Name { get; protected set; } = "Cheeze";

The accessor can also be internal, internal protected, or private.

Read-Only Properties

In addition to flexibility with visibility, you can also initialize read-only auto-properties. Here’s an example:

public List<string> Ingredients { get; } =

new List<string> { "dough", "sauce", "cheese" };

This example also shows how to initialize a property with a complex type. Also, auto-properties can’t be write-only, so that also precludes write-only initialization.

properties, it takes care of all the requirements required to ensure the property is immutable. Consider, for example, the FingerPrint class in the following example:

public class FingerPrint

{

public DateTime TimeStamp { get; } = DateTime.UtcNow;

public string User { get; } = System.Security.Principal.WindowsPrincipal.Current.Identity.Name;

public string Process { get; } = System.Diagnostics.Process.GetCurrentProcess().ProcessName;

}

View Demo

Cautionary notes

Take care to not confuse auto-property or field initializers with similar-looking expression-body methods which make use of => as opposed to =, and fields which do not include { get; }.

For example, each of the following declarations are di erent.

public class UserGroupDto

{

// Read-only auto-property with initializer:

public ICollection<UserDto> Users1 { get; } = new HashSet<UserDto>();

// Read-write field with initializer:

public ICollection<UserDto> Users2 = new HashSet<UserDto>();

// Read-only auto-property with expression body:

public ICollection<UserDto> Users3 => new HashSet<UserDto>();

}

Missing { get; } in the property declaration results in a public field. Both read-only auto-property Users1 and read-write field Users2 are initialized only once, but a public field allows changing collection instance from outside the class, which is usually undesirable. Changing a read-only auto-property with expression body to read-only property with initializer requires not only removing > from =>, but adding { get; }.

The di erent symbol (=> instead of =) in Users3 results in each access to the property returning a new instance of the HashSet<UserDto> which, while valid C# (from the compiler's point of view) is unlikely to be the desired behavior when used for a collection member.

The above code is equivalent to:

public class UserGroupDto

{

//This is a property returning the same instance

//which was created when the UserGroupDto was instantiated. private ICollection<UserDto> _users1 = new HashSet<UserDto>(); public ICollection<UserDto> Users1 { get { return _users1; } }

//This is a field returning the same instance

//which was created when the UserGroupDto was instantiated.

public virtual ICollection<UserDto> Users2 = new HashSet<UserDto>();

//This is a property which returns a new HashSet<UserDto> as

//an ICollection<UserDto> on each call to it.

public ICollection<UserDto> Users3 { get { return new HashSet<UserDto>(); } }

}

Section 72.4: Null propagation

The ?. operator and ?[...] operator are called the null-conditional operator. It is also sometimes referred to by other names such as the safe navigation operator.

This is useful, because if the . (member accessor) operator is applied to an expression that evaluates to null, the program will throw a NullReferenceException. If the developer instead uses the ?. (null-conditional) operator, the expression will evaluate to null instead of throwing an exception.

Note that if the ?. operator is used and the expression is non-null, ?. and . are equivalent.

Basics

var teacherName = classroom.GetTeacher().Name;

// throws NullReferenceException if GetTeacher() returns null

View Demo

If the classroom does not have a teacher, GetTeacher() may return null. When it is null and the Name property is accessed, a NullReferenceException will be thrown.

If we modify this statement to use the ?. syntax, the result of the entire expression will be null:

var teacherName = classroom.GetTeacher()?.Name;

// teacherName is null if GetTeacher() returns null

View Demo

Subsequently, if classroom could also be null, we could also write this statement as:

var teacherName = classroom?.GetTeacher()?.Name;

// teacherName is null if GetTeacher() returns null OR classroom is null

View Demo

This is an example of short-circuiting: When any conditional access operation using the null-conditional operator evaluates to null, the entire expression evaluates to null immediately, without processing the rest of the chain.

When the terminal member of an expression containing the null-conditional operator is of a value type, the expression evaluates to a Nullable<T> of that type and so cannot be used as a direct replacement for the expression without ?..

bool hasCertification = classroom.GetTeacher().HasCertification;

// compiles without error but may throw a NullReferenceException at runtime

bool hasCertification = classroom?.GetTeacher()?.HasCertification;

// compile time error: implicit conversion from bool? to bool not allowed

bool? hasCertification = classroom?.GetTeacher()?.HasCertification;

// works just fine, hasCertification will be null if any part of the chain is null