C# 7.0 And C# 7.1 New Features - Part Two

This article explains the new features of C# 7.0 & C#7.1. It covers all the latest features such as Discards, Pattern Matching, Generalized async return types, Async Main (Main Method returning Task), Infer Tuple Element Names, Default Literal Expressions & Type Inference and Pattern Matching with Generics.

This article is the second article of the series New Features of C# 7.x. If you missed the first part of this article, then I recommend you to go through the below-provided link.

Top 10 New Features of C# 7 With Visual Studio 2017

In the preceding article, I covered following features of C# 7.0.

1. Local Functions or Nested Functions
2. Binary Literals
3. Digit Separators
4. Pattern matching
5. ref returns and ref Locals
6. Tuples (Tuples Enhancement)
7. Throw Expressions
8. Expression Bodied Members (methods, properties, constructors, destructors, getters, setters, indexers, operators, Main method)
9. Out variables (enhancement for out variables)
10. Deconstruction

Rather than using term C# 7.0, C# 7.1 and C# 7.2, C# 7.3, I may be using the term C# 7.x instead.

I am going to cover following features of C# 7.x in this article.

1. Discards (C# 7.0)
   
   
   1. Out parameter variable in C# 7 with Discard
   2. Discard multiple parameter names
   3. Discard multiple variable names and their data types
   4. Discard with tuples
   5. Using Discard standalone
   6. Using Discard with the ‘is’ expression Pattern Matching
   7. Discard with Tasks
   8. Simplest and smallest example of Discard

2. Pattern Matching (C# 7.0)
   
   
   1. The ‘is’ type Pattern Matching
   2. “switch” Statement Pattern Matching
   3. “switch” Statement with “when” condition Pattern Matching
   4. Does Sequence Matters for Switch Case Expression in C# 7.x? (Big change)
      
      
3. Generalized async return types (C# 7.0)
   
   
   1. Async method returning Task
   2. Async method returning Task<T>
   3. Async method returning void
   4. Async method returning ValueTask <T>

4. Async Main: Main Method returning Task (C# 7.1)
   
   
   1. Understanding the Existing Functionality and Behaviour of Main Method
   2. What is new in C# 7.1 for Main Method
      
      
5. Infer Tuple Element Names (C# 7.1)
   
   
   7. Using Tuple before C# 7.0
   8. Using Tuple in C# 7: Without Using the Tuple Keyword
   9. Using Tuple in C# 7: Accessing member with meaningful name
   10. Using Tuple in C# 7: Deconstructing Tuple
   11. Using Tuple in C# 7.1: Inferring element name
       
       
6. Default Literal Expressions and Type Inference (C# 7.1)
   
   
   7. Overview of Default Literal Expressions before C# 7.1
   8. Enhancement for Default Literal Expressions in C# 7.1
      
      
7. Pattern Matching with Generics (C# 7.1)

C# 7 allows us to discard the returned value which is not required. Underscore (_) character is used for discarding the parameter. The discard parameter (_) is also referred to as write-only. We cannot read the value from this parameter.

Before jumping to discard, I want to explain about out keyword in C#. Have a look at the below code snippet.

Before C# 7

You can see that in the preceding code snippet, I am just trying to convert a string to an integer. If it is converted successfully, then I am printing a message.

In C# 7, we can declare out variable as inline variable so the preceding code snippet can be written as -

As you see, I am using a local variable x just for passing it as a parameter but I am using this variable nowhere. So, if the variable is not used, then it should not have a name and no value should be assigned to it.

Discard does the same thing, i.e. instead of using the variable name, we can just use the underscore character.

This discard option is not limited to a single variable. You can use discard with any number of variable. Let’s try to understand it with another example.

Write a function with name Result which accepts 2 integers and returns sum, difference, multiplication, division, and modular division of these 2 numbers.

And, call it like -

In Visual Studio 2017, you notice that it shows 3 dots for each variable which can be declared inline. So, you can call the Result method by using the below code snippet.

However, I am using only the variable “sum” but not using the variable “diff”, “mult”, “div” and “modDiv”, so I can replace all these by the underscore (_) characters as shown in the below code snippet.

So, you can see how we are discarding the variable we are not using.

You know that I am not passing the variable name but data type passed. However, datatype passing is also optional, and we can remove data type as well. Following is the code snippet for the same.

You can see in the preceding screenshot that I need only product id and product name, so I have discarded all other parameters of the tuple.

Following is the complete code for the same

Have a look at the below code snippet.

You can see that I am calling UpdateCustomer() & UpdateProduct() method conditionally in ternary operator.

So, I am calling 2 methods conditionally and storing the result in a variable “recordsUpdated”. But, I am not using the value of variable “recordsUpdated”. So, let’s call it like below.

You get the compiler error. Following is the screenshot for the same.

Now, resolve it using discard and call it like the following statement.

In case of pattern matching, discard can be used with ‘is’ expression.

Let’s have a look at the below code snippet.

You can see that in the above code snippet, I am creating a variable with name “task” but I am not using it. So, it can be discarded and we can write it as -

I am just showing an example to explain how to use discard with the task, but the above code snippet can be optimized.

Below code snippet is one of the simplest and smallest examples of discard.

Pattern matching is one of the most popular features of C# 7. I also explained pattern matching in my previous article, but right I am going to explain it in depth.

The ‘is’ keyword is not new to C#, but in C# 7, you can assign it to a new variable in the same expression.

Before C# 7

In C# 7

If you compile the above statement in C# 6 or below version, then you get compile time error.

So, you can see that in C# 7, as soon as the type matches, we can assign it to a new variable.

Before C# 7, we could not use pattern matching with switch expression. In C# 6 and earlier versions, limited types were supported and that must had been a compile time constant otherwise you get the following error.

“A switch expression or case label must be a bool, char, string, integral, enum, or corresponding nullable type in C# 6 and earlier.”

Let’s use the same example which I have used for ‘is’ pattern matching and convert the code to switch expression.

In C# 7

Compile “switch” Statement Pattern Matching with C# 6

Now, try to compile the same in C# 6. You get the errors as shown in the following screenshot.

In C# 7, we can use “when” with switch case for better pattern matching.

If we talk about the sequence for case expression, apparently, the answer is YES. In C# 7.0 and above versions, sequence matters for case expression.

Let’s create a simple console app to prove that statement. Create a console app with following code snippet.

Output

You can see that in the above code snippet, when I am passing 0, 5, & true, then it has more than one matching conditions but the code is being executed for the first matching block. This is a significant change and you must remember it.

Before going through the generalized async, let’s have a look on asynchronous programming and try to understand it how it works.

You can see that the return type of the method “PrintPrimeNumbers()” is Task.

Now, change the return type of the method as Task<T>.