How to use C# 7.2 (7.x – minor releases) in your Project

C# 7.0 and other minor releases (7.x) are loaded with many awesome features and I’ve been all those nice features recently. You can have a look here. I have seen many people facing issues with using these features. So in this quick post, I will discuss how you can leverage C# 7.x features.

Using Visual Studio 2017

To use C# 7.x features, Microsoft recommends to upgrade the IDE to Visual Studio 2017. To use C# latest minor releases C# 7.X (currently C# 7.2), this is not enough, we need to follow the below steps

  1. Right click on the project => Select Properties
  2. Select Build tab from the left pane.
  3. Go down and select Advanced button
  4. Select the Language version as

Here we can see tha the default selection is C# latest major version (default) which means 7.0. We also have the option to select specific versions like 7.0/7.1 but for 7.2, we need to select C# latest minor version (latest).

Using Visual Studio 2015

As mentioned above that Microsoft recommends to use Visual Studio 2017 for C# 7.x features but as these features are implemented by compiler so as long as your build is pointing to correct version of CSC, you can build the new features. However, Visual Studio 2015 may not like it as it doesn’t understand the new features and you may not get intellisense or any other IDE support.

To use C# 7.X in Visual Studio 2015, install the following nuget package


Once, you install this package, you should be able to use the latest language feature in VS 2015. However you might red   squiggly in the editor as

Here we can see that even the VS2015 editor is complaining but it is getting built.

Using System.ValueTuple

ValueTuple is not available by default as part of C# 7.0, we need to install following nuget package


Hope you like the post and able to use the C# latest features.



Use the awesomeness of Pattern Matching with C# 7.0

Pattern Matching is a new feature which was introduced with C# 7.0 which allows us to write cleaner and concise code in many different scenarios. This feature can be said as an extension of is and as operators that we already have in C#. I wrote a post on it earlier, you can take a look here. This feature can be broadly devivded in two sections

  1. Using Is Expression
  2. Using Pattern Matching in Switch Statements

Using Is Expression:

Prior to C# 7.0, Is operator was used to check the type of a variable and based on the type, it returns true or false but with C# 7.0, Is Expression provides following three types of pattern matching

  1. Const Pattern
  2. Type Pattern
  3. Var Pattern

Let’s discuss each with examples

Const Pattern: It allows us to check an object with any value. Let’s see an example

static void IsConstExpression()
    Object obj = 2;
    string name = "Brij";

    // null check
    if (obj is null)
        Console.WriteLine("Obj is null");

    // Constant value check
    if(obj is 2)
        Console.WriteLine("Obj has value 2");

    // String value check
    if(name is "Brij")
        Console.WriteLine("name has value \"Brij\"");

Above, we can see that we can check to any value including null.

Type Pattern: It allows us to confirm the type of the object and also assigns the value to a new variable of the given type. Prior to C# 7.0, we also had the similar feature but here we can assign to the new variable as mentioned. Lets see the example

static void IsTypeExpression()
    Object obj = 2;

    var objPerson = new Person() { FirstName = "Brij", LastName="Mishra" };
    var objNewPerson = new Employee() { FirstName = "Anvit", LastName = "Mishra", Company ="ABC Ltd" };

    if (obj is int i)
        Console.WriteLine($" Variable i has the value {i}");

    if (objPerson is Person person)
        Console.WriteLine($" p is of type {person.GetType().Name} and first name is {person.FirstName}");

    if (objNewPerson is Employee newPerson)
        Console.WriteLine($" p is of type {newPerson.GetType().Name} and first name is {newPerson.Company}");

    if (objNewPerson is Person objPer)
        Console.WriteLine($" p is of type {objPer.GetType().Name} and first name is {objPer.FirstName}");


Lets see the output


Here Employee inherits from Person. So in the last statement, we have the actual object of Employee but it assigned to a variable of base type.

Var Pattern: This is special case pattern where we check the type as var. This has one difference with the type pattern as it returns true even if it is null. Let’s see example

static void IsVarExpression()
    Object obj = new Person() { FirstName = "Brij", LastName = "Mishra" };

    if (obj is var p)
        Console.WriteLine($"Var Pattern : P is of type {p?.GetType().Name}.");

    obj = null;

    if (obj is var per)
        Console.WriteLine($"Var Pattern : P is of type {per?.GetType().Name}.");

The output will be as

Here we can see that the second check is also true but since it is null, nothing it displayed where we wrote the type name. Now lets move to switch statements.

Pattern Matching in Switch Statements:

The patterns that we discussed in previous section, can be leveraged in switch statements as well. This becomes very handy when the number of testing conditions grows and using Is pattern becomes tough to maintain.

Earlier switch statement was only supporting constant pattern with limited value types and strings but now we can use Type and var patterns as well. Let’s see the example

    case Manager objM:
        Console.WriteLine("p is of Manager type");
    case Employee objE:
        Console.WriteLine("p is of Employee type");
    case Person objP:
        Console.WriteLine("p is of Person type");
    case null:
        Console.WriteLine("p is null");

Here Person is the base class and with the hierarchy Person->Employee->Manager. Based on the type of p case statement gets executed and in case of null, last one gets executed. Here, the key is the most derived type should be first statement. Compiler also gives a warning if the order is not correct. C# 6.0 also provides us capability to use When clause in switch case. Let’s see the example

    case Employee objE when objE.Grade == 5:
        Console.WriteLine($"{objE.FirstName} is Manager");
    case Employee objE when objE.Grade == 5 && objE.Rating >= 3:
        Console.WriteLine($"{objE.FirstName} is Manager and eligible for additional bonus");
    case var objVar:
        Console.WriteLine("P is not a Employee and is of Type {objVar?.GetType().Name}   ");

Here we can see we can add additional filters in case statements which can be very useful in many scenarios. It also allows to add more that one filter and have various kind of combinations. I have used the var pattern as well in last case statement.

Hope you have enjoyed the post and will be able to use this feature in your day to day work.