C# 7.0, which comes with Visual Studio 2017, allows you to write local functions or nested functions. The local function provides you with the ability to declare methods/functions inside an already defined methods body. It has the same capability as normal methods, but it will be scoped to the method block where they are declared.

In earlier versions of C#, we needed to write the method bodies separately and then we needed to call one method from the other. Here is the old way to write a method called by another method:

     public static Person GetBloggerDetails() 
     { 
       return new Person 
       { 
         FirstName = "Kunal", 
         LastName = "Chowdhury", 
         Blogs = GetBlogs() 
       }; 
     } 
 
     private static List<string> GetBlogs() 
     { 
       return new List<string> { &quot...

There were two types of literals supported in C# prior to C# 7.0. They are decimal literals and hexadecimal literals. For example, 490 is a decimal literal, whereas 0x50A or 0X50A is a hexadecimal literal, equivalent to the decimal value 490. Please note that the prefixes 0x and 0X define the same thing.

Here's an example for you to easily understand how a hexadecimal literal is used in C#:

 
    class Program 
    { 
      static void Main(string[] args) 
      { 
        double height = 490; 
        double width = 1290; 
 
        double heightInHex = 0x1EA; // equivalent to decimal 490 
        double widthInHex = 0x50A; // equivalent to decimal 1290 
 
        Console.WriteLine("Height: " + heightInHex + " Width: " + widthInHex); 
      } 
    } 

Along with C# 7.0, Microsoft added more support to literals, and they...

Digit separator is a new feature in C# 7.0. You can use _ (underscore) inside numeric literals as a digit separator. The purpose of it is none other than improving the readability of the value in code.

You can put a digit separator (_) wherever you want between digits. You can have multiple underscores (____) too. They will have no effect on the value. This is shown in the following code snippet:

    var decimalValue1 = 1_50_000; // better than 150000 
    var decimalValue2 = 25_91_50_000; // better than 259150000 
 
    // you can use multiple underscores too 
    var decimalValue3 = 25_91__50___000; // better than 259150000 

You can also add digit separators to a binary literal and/or hexadecimal literals:

    var binaryValue = 0b1010_1011_1100_1101_1110_1111; 
    var hexadecimalValue = 0xAB_C_0_D_EF_578; 
 

Please note that the following conventions...

Pattern matching is a new notion introduced in C# 7.0, which adds some power to the existing operators and statements. You can perform pattern matching on any data type and from that statement you can extract the value of that data type. There are two different types of pattern matching in C# 7.0:

• The Is expression with pattern matching
• Switch statements with pattern matching

In this type of pattern matching, it introduces a new pattern variable out of the expression, allowing you to extract the value of the type. It is similar to the out variable, but with a limited scope to the surroundings.

Let's look at an example. In the old method,...

Since C# 1.0, the language has supported passing parameters to a method by reference using the ref, but there exists no mechanism to return a safe reference to stack or heap memory locations.

In C# 7.0, Microsoft has provided the option for developers to return values by reference and store them in local variables as a reference pointer.

Before going into an example of return by reference, let us first look at an example of how the return by value works with a pass by reference parameter. In the following example, the GetAsValue method accepts a third parameter of type integer as a reference, and returns a value to the callee, which gets stored in the local variable name:

    public static void DemoReturnAsValue() 
    { 
      var count = 0; 
      var index = 0; 
      string[] names = { "Kunal", "Manika", "Dwijen" };...

A tuple is a finite ordered list of elements. In C#, it's not a new thing, having been available since .NET Framework 4.0. It is useful when you want to return multiple values from a method without creating a separate class or collection to hold the data. Tuples are declared in the manner, Tuple<T1, T2, T3, ...> and are available under the System namespace.

By default, a tuple can hold up to eight value types, but you can extend it by adding the reference of System.Runtime.

Although this is useful when returning multiple values, you need to create an allocation for the System.Tuple<...> object. The following example demonstrates how to return multiple values using a tuple:

   public static Tuple<string, string> GetAuthor() 
   { 
     return new Tuple<string, string>("Kunal Chowdhury", 
                             ...

The earlier versions of C# had some limitations on throwing exceptions from certain places, which caused developers to write more code to validate and raise exceptions. In C# 7.0, those limitations have been removed to reduce the overload.

The Null Coalescing operator now allows you to throw an exception in the middle of the expression without explicitly checking for null:

    m_designation = designation ?? 
          throw new ArgumentNullException(designation); 

It is now possible to throw an exception from the Conditional operator too:

    m_department = department == null ?  
           throw new ArgumentNullException(department) :  
           department; 

C# 7.0 also allows you to throw an exception from expression-bodied member, as shown in the following code snippet:

    public void SetSalary(double salary) =>  
           throw new...

In C# 6.0, Microsoft introduced the expression-bodied methods and properties, but these had a few limitations, which didn't allow us to use them in the constructors, destructors, and getters/setters of properties.

With C# 7.0, these limitations are no more, and you can now write them for single-liner constructors and destructors, as well as the getter and setter of a property. Here's how you can use them:

    public class Person 
    { 
      private string m_name; 
 
      // constructor 
      public Person() => Console.WriteLine("Constructor called"); 
 
      // destructor 
      ~Person() => Console.WriteLine("Destructor called"); 
 
      // getter/setter properties 
      public string Name 
      { 
        get => m_name; 
        set => m_name = value; 
      } 
    } 

When you run the...

Currently in C#, we need to first declare a variable before we pass it as an out parameter to a method. You can use a var while declaration if you initialize them in the same line, but when you don't want to initialize explicitly, you must declare them, specifying the full type:

    // predeclaration of 'out' variable was mandatory 
    int result; // or, var result = 0; 
    string value = "125"; 
 
    int.TryParse(value, out result); 
 
    Console.WriteLine("The result is: " + result); 

In C# 7.0, the out variables can be declared right at the point where they are passed as an out parameter to a method. You can now directly write int.TryParse(value, out int result); and get the value of the out parameter, to use it in the scope of the enclosing block:

    static void Main(string[] args) 
    { 
      string...

Deconstruction is a syntax to split a value into multiple parts and store those parts individually into new variables. For example, tuples that return multiple values. Let us take the following method as an example, which returns a tuple of two string variables, Title and Author (see the New changes to tuples section):

    public (string Title, string Author) GetBookDetails() 
    { 
       return (Title: "Mastering Visual Studio 2017",
               Author: "Kunal Chowdhury"); 
    } 

Now, when you call the method GetBookDetails(), it will return a tuple. You can access its elements by calling the element name, as follows:

  var bookDetails = GetBookDetails(); // returns Tuple 
  Console.WriteLine("Title  : " + bookDetails.Title); 
  Console.WriteLine("Author : " + bookDetails.Author); 

In a...

Prior to C# 7.0, async methods had to return either void, Task, or Task<T>. As Task is a reference type, returning such an object from async methods can impact performance because it allocates an object into memory even though it returns a cached object or runs asynchronously.

To overcome this, C# 7.0 introduces the ValueTask type, which is set to prevent the allocation of a Task<T> object when the result of the async operation is already available. Using it, the async methods can return types other than Task, Task<T>, and void:

  public async ValueTask<long> GetValue() 
  { 
    return await Task.Run<long>(() => 5000); 
  } 

If you receive an error accessing ValueTask in C# 7.0, you must explicitly reference System.Threading.Tasks.Extensions from the NuGet package library. To install the package, either...

In this chapter, we have learned about the new features introduced in C# 7.0, along with the release of Visual Studio 2017. We have also demonstrated each of them with examples/code.

At a glance, we have learned about local or nested functions, literal improvements, the new digit separators, pattern matching, ref returns and locals, changes in tuples, changes to the throw expression, and expression-bodied members. We also learned about the new changes to the out variables, deconstruction syntax, and the uses of generalized async return types.

As we have become familiar with the features of C# 7.0, let's move on to the next chapter, where we will learn about building applications for Windows using Windows Presentation Foundation. We will also learn how to design a XAML UI, do data bindings, and much more.