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

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

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

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

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.

Cheers,
Brij

Advertisements

How to use Null Conditional operators

Null values are very special in any language, specifically in C#. Every .NET developer must have pulled his/her hair at some point or other while dealing with it. C# is getting mature by adding more capabilities to handle the null values so that we don’t need to write long repetitive code to handle it. This operator was introduced with C# 6.0 sometimes also referred as safe navigation operator, and can be panacea for the most common NullReferenceException. There are few related topics like Null Coalescing operator, Nullable types, which I will advise to take a quick look before proceeding.

What is Null Conditional Operator?

This is a new operator introduced with C# 6.0, helps in performing null check while accessing its members. It provides following two syntax

  1. First operator: ?.   (Also called elvis operator)
  2. Second operator: ?[

Let’s see it with examples

First Null Conditional Operator (?.):

This operator allows us to access the members or elements of the provided instance only when it is not null. So before moving further, lets create few classes for the example

public class Person
{
    public string FirstName { get; set; }

    public string LastName { get; set; }

    public int Age { get; set; }

    public List <Address> Addresses { get; set;}

    public Person Spouse {get; set;}
}

public class Address
{
    public string Address1 { get; set; }
    public string Address2 { get; set; }

    public string City { get; set; }

    public string State { get; set; }

    public string Zip { get; set; }
}

If you have to access properties of the person, the usual way of doing it

if(p != null)
{
    string name = p.FirstName;
    int age = p.Age;
}

Now lets see using the ?. operator

string name = p?.FirstName;
int? age = p?.Age;

Here we dont need to have a null check as it is taken care by the null conditional operator. name is assigned to null if either object p is null or FirstName is null. While for age, I had to change the age variable as Nullable type because for value types, this operator returns a nullable type which is easily understandable as it would have no value (or null) if p is null.

Now if want to access the properties of Spouse then normally code would be as

if(p != null && p.Spouse != null)
{
    string name = p.Spouse.FirstName;
    int age = p.Spouse.Age;
}

which can be written as

string name = p?.Spouse?.FirstName;
int? Age = p?.Spouse?.Age;

Here, we avoided two null check and code looks much cleaner and concise. This operators becomes more helpful for the descending types. You must have written similar code like below numerous times while handling a service response

if (response != null && response.Results != null && response.Results.Status == Status.Success)
{
    // Handle response
}

this can be as

if (response?.Results?.Status == Status.Success)
{
        // Handle response
}

It looks super clean now. It could be more granular based on the scenario. Now let’s see another operator.

Second Null Conditional Operator (?[): This operator allows you to have a check over index operator. Let’s see the example.
Here I want to see the city of the second address of the person so normally, we will write it as

if(p!=null && p.Addresses != null && p.Addresses.Count > 1)
{
    string city = p.Addresses[1].City;
}

This we can write now as

string city = p?.Addresses?[1]?.City;

Now you can assume if I have read the same for spouse then how consize code would be.

Other Usages:
It can be used while calling method of instance like

p?.ToString();

We can use it with delegate and events as well like

myCustomDelegate?.Invoke(args)

// Note : myCustomDelegate?(args) won't work and it will be an compile time error

myCustomEvent?.Invoke(this, args);

I found this feature very useful in our day to day coding as we save lot of repetitive code. Hope you find it useful as well.

Cheers,
Brij

String Interpolation in C# with Examples

String is one of the most used types in C# and it provides many options playing with it. I wrote a post earlier where I discussed about String, StringBuilder and String.Fromat. You might want to have a look here. Today I am going to one of the very nice features that got introduced with C# 6, named String Interpolation.

What is String Interpolation?

String Interpolation is a process of generating the output string from a string literal by replacing the placeholders with the actual values. These placeholders could be just variable names or some expressions. It is like template processing where the variables are replaced with actual values to generate the final output. We already have String.Fromat where the values are replaced based on the indexing of provided parameters but we don’t need that now. Interpolation is very common feature in many new libraries and frameworks like Angular.

We will see multiple examples based on various usage of string interpolation. Lets start with basic one

Example 1:

string name = "Brij";
string topic = "String Interpolation";

// Prior to C# 6
Console.WriteLine(string.Format("Hello {0}. Lets learn {1}",name, topic));

// C# 6 and later
Console.WriteLine($"Hello {name}. Lets learn {topic}");

Here both will give the same output. The second option is much cleaner and readable.  As in the above example, to use it, the string should start with $. Let’s see the syntax of interpolated string

$"<text> {<expression> [,<field-width>] [:<format-string>] } <text> ..."  
  • field-width – It defines the width of the field. If positive then value is right aligned and if negative, it is left aligned. If the value is less than the width of the value, there is no impact in the output.
  • format-string – It can be used to define the format of the value like datetime, currency, number etc.

Note – There should be no space between $ and ” at the start of the string else it will htow an compile time error.
Example 2:

int langversion = 6;
string VSVersion = "Visual Studio 2015";
DateTime releaseDate = new DateTime(2015, 7, 20);

Console.WriteLine($"C# {langversion: 0.0} was released with {VSVersion} on {releaseDate: MMM d yyyy}.");

// output

C#  6.0 got released with Visual Studio 2015 on  Jul 20 2015.

If we have any special characters that could provide different meaning to literal then it should be escaped like “, \ etc . If we want a curly braces ({ or }) in the string then it should be written twice as {{ or }}. To use few language elements like colon (:) in expression, it should be delimited by parenthesis as well in expression.

Example 3:

Console.WriteLine($"We can use special meaning characters like \", \\ by escaping it in literal text.");
Console.WriteLine($"We can use {{curly braces}} by using it twice.");
Console.WriteLine($"To use it in expression it should be delimited by paranthesis"
+$" like  2*2 = 4 is {(2*2 == 4? "Correct" : "Incorrect")}");

// Output
We can use special meaning characters like ", \ by escaping it in literal text.
We can use {curly braces} by using it twice.
To use it in expression it should be delimited by paranthesis like  2*2 = 4 is Correct

In the above example, we have seen that how to use special characters in string literals and in expression. Let’s see one more example

Example 4:

Console.WriteLine($"3 power 4 using Math function { Math.Pow(3, 4)} and using custom power "
$"function { CustomPow(3, 4)}.");

// Output
3 power 4 using Math function 81 and using custom power function 81.

Here we can see that we can use any framework class or even custom function in this expression.

Hope you have enjoyed this feature and will start using it.

Cheers,
Brij

What are Immutable types?

In C#, primarly we have two types of objects: reference type and value type. Value type objects always have default value and created on stack. When we assign value type variable to another variable, a new copy gets created. While reference type objects default to null and created on heap. Multiple variables can point to the same object, it means changing the value using one, will reflect accross variables. There is one more type called Nullable type which is similar to value type with additional capability to have no value if it is unassigned. You can learn more about from one of my previous posts here

A reference type can be categorized in two types : Mutable and Immutable. The plain english meaning is “Can Change” and “Cannot Change” respectively and which is same here as well.

It means an Immutable type object cannot be changed after it’s creation/initialization and if one tries to change, a new copy gets created (if allowed) and returned. In other words, it is a reference type but having value type semantics. String is one of the most used immutable types and it is provided by the .NET framework.

Normal class that we create, are mutable type. Let’s see an example

    class Program
    {
        static void Main(string[] args)
        {
            Person objPerson = new Person() { Name = "Brij", Age =32 };
            UpdatePerson(objPerson);
            Console.WriteLine(objPerson.Name);
            Console.ReadKey();
        }

        static void UpdatePerson(Person P)
        {
            P.Name += " Mishra";
        }
    }

    public class Person
    {
        public string Name { get; set; }

        public int Age { get; set; }
    }

So in this example the output will be Brij Mishra as the same object got changed. This class can also be modified as where we just provide the getter and the values then can be modified either at constructor or any other method inside the same class.

public class Person
{
    private string _name;
    public string Name { get { return _name; } }

    private int _age;
    public int Age { get { return _age; } }

    public Person(string name, int age)
    {
        this._name = name;
        this._age = age;
    }
}

Now to make it an immutable object, we have two options:

  1. Use Const
  2. Use Readonly

So I can make the class as

   public class Person
    {
        private readonly string _name;
        public string Name { get { return _name; } }

        private readonly int _age;
        public int Age { get { return _age; }  }

        public Person(string name, int age)
        {
            this._name = name;
            this._age = age;
        }
    }

Now once we create an instance of this class, it cannot be updated as all the properties are readonly. Even, we cannot update in another new method in the same class as in the previous example. We can use the Const instead of readonly but in that case, we will loose the ability to assign the value while object creation, instead we will have to provide the value at class definition. One more drawback, as const variable initialized at Class level itself, also called compile time constant so it would be same for all the instances of that type.

Now lets create another class address and have a List of Addresses in the class as

 public class Person
    {
        private List
<Address> _addresses;
        private readonly string _name;
        public string Name { get { return _name; } }

        private readonly int _age;
        public int Age { get { return _age; }  }

        public Person(string name, int age, List
<Address> addresses)
        {
            this._name = name;
            this._age = age;
            _addresses = addresses;
        }
        public List
<Address> Addresses { get { return _addresses; } }
    }

    public class Address
    {
        public string Address1 { get; set; }

        public string Address2 { get; set; }

        public string City { get; set; }

        public string State { get; set; }

        public string Zip { get; set; }
    }

As here the list of address has only get property exposed, it means we cannot replace the whole collection but certainly we can update the items from the list by adding and/or removing an item as

Person objPerson = new Person("Brij", 32, addresses);
objPerson.Addresses.Add(new Address());

Now, to make the Person class Immuatble, we need to change it as readonly collection as

public class Person
{
    private List
<Address> _addresses;
    private readonly string _name;
    public string Name { get { return _name; } }

    private readonly int _age;
    public int Age { get { return _age; }  }

    public Person(string name, int age, List
<Address> addresses)
    {
        this._name = name;
        this._age = age;
        _addresses = addresses;
    }

    public ReadOnlyCollection
<Address> Addresses { get { return _addresses.AsReadOnly(); } }
}

Now we wont be able to add or remove items from list. Still we have here one gap and using we can update any existing address object as Address is not a immutable type.

To make it immutable we will require to make all the properties readonly or const.

So to make an object immuatble, all the internal type used, should also be immutable and all the collection should be readonly.

C# 6 added a feature that says if we have a auto property with only a getter then it can be only initialized in constructor. Behaind the scene, it uses private readonly property as

public class Person
{
    public string Name { get; }

    public int Age { get; }
}

Here if we try to update the properties other than the constructor, it will throw an error stating that it is readonly.

Hope you all have enjoyed the post.

Cheers
Brij

TransactionScope: A simple way to handle transactions in .NET

Have you ever tried implementing transactions using C# code? Normally, we implement transactions in SQL where multiple Insert/Update statements takes part in it. A Transaction follows the ACID (Atomicity, Consistency, Isolation, Durability) rule where either all the statements get committed or all get canceled and rolled back. TransactionScope allows us to implement it at application level. There could be some scenarios where you are required to do different operations in the same database or even multiple databases (distributed transaction) or due to some other constraints, it cannot be done at database level. It is also very helpful for application developers if they have less exposure to database.

What is TransactionScope

TransactionScope got introduced with .NET 2.0 as part of  System.Transaction. It is a class which provides a simple way to make a set of operations as part of a transaction without worrying about the complexity behind the scene. If any of the operation fails in between, entire transaction would fail and rolled back  which undo all the operation that got completed. All this would be taken care by the framework, ensuring the data consistency.

How to use the TransactionScope?

To use this, you need to add the reference of System.Transactions reference which is part of framework libraries (normally it wont be added by default). Once it get added, add the namespace System.Transactions wherever we want to use this. The syntax would look as

try
{
    using (TransactionScope scope = new TransactionScope())
    {
        // Do Operation 1
        // Do Operation 2
        //...

        // if all the coperations complete successfully, this would be called and commit the trabsaction. 
        // In case of an exception, it wont be called and transaction is rolled back
        scope.Complete();
    }
}
catch (ThreadAbortException ex)
{
    // Handle exception
}

Here we can see that we have used Disposable block while creating instance of TransactionScope, it makes sure the dispose gets called when it gets out of the block and ends the transaction scope.

In one Transaction scope, we can do multiple operation connecting to different databases as

using (TransactionScope scope = new TransactionScope())
{
    using (con = new SqlConnection(conString1))
    {
        con.Open();

        // Do Operation 1
        // Do Operation 2
        //...
    }

    using (con = new SqlConnection(conString2))
    {
        con.Open();

        // Do Operation 1
        // Do Operation 2
        //...

    }

    scope.Complete();
}

Here we are using two connection strings to connection different databases. We can use as many based on our requirement. We can have nested transactions as well. It could be as

public void DoMultipleTransaction()
{       
    try
    {
        using (TransactionScope scope = new TransactionScope())
        {
            using (con = new SqlConnection(conString1))
            {
                con.Open();
                // Do Operation 1
            }

            OtherTransaction();
            scope.Complete();
        }
    }
    catch (ThreadAbortException ex)
    {
        // Handle exception
    }
}

private void OtherTransaction()
{
    using (TransactionScope scope = new TransactionScope())
    {
        using (con = new SqlConnection(conString2))
        {
            con.Open();
            // Do Operations
        }
        scope.Complete();
    }
}

Here the outermost transaction is called as rootscope and here even if the inner transaction (OtherTransaction above) gets completed by calling scope.Complete(), if the rootscope complete could not be called due to various reasons, then the complete transaction would be rolled back including inner transactions.

Note: You might get one of the following exception while executing distributed trsanctions

  1. MSDTC on server is unavailable
  2. Network access for Distributed Transaction Manager (MSDTC) has been disabled.

 

Both the error are due to the same reason, first one occurs when you have the database and the application the same server while 2 if on the other server. For same server, go to run-> cmd-> services.msc. Run the service named Distributed Transaction Coordinator and make the startup type automatic so that it gets started again in case of system restart. For 2, follow the link to cofigure MSDTC.

TransactionScope provides various TransactionScopeOptions which defines transactions behavior for the scope. Lets see an example

using (TransactionScope scope = new TransactionScope())
{
    // Do Operation
    using (TransactionScope scope1 = new TransactionScope(TransactionScopeOption.Required))
    {
        // Do Operation
        scope1.Complete();
    }
    using (TransactionScope scope2 = new TransactionScope(TransactionScopeOption.RequiresNew))
    {
        // Do Operation
        scope2.Complete();
    }
    using (TransactionScope scope3 = new TransactionScope(TransactionScopeOption.Suppress))
    {
        // Do Operation
        scope3.Complete();
    }

    scope.Complete();
}

Here we created three transactions under the parent transaction with different TransactionScopeOptions. By default the scope is required, which applies to parent transaction here. It is a rootscope which creates a new transaction, and mark it as an ambient transaction. scope1 is also created with required and as we have already an ambient transaction (scope) so it joins the parent transaction. scope2 got created with option as RequiresNew which means it is a new transaction which is independently works with ambient transaction. scope3 got created with suppress option, which means it doesn’t take part in any ambient transactions. It gets executed regardless whether ambient transaction executes successfully or not. All the ambient transactions gets committed once the parent (global) scope completes.

Hope you enjoyed this post and will be using transaction in your future requirements.

Cheers,
Brij

TracePoint : An awsome feature of Visual Studio

Have you ever wanted to see the intermediate values of a variable which is inside a loop without pausing the execution via breakpoint?

I am sure you will say YES. A visual studio feature called Tracepoint can be very helpful in these scenarios.

Breakpoint allows to stop at a point where you can see the variable value but you may loose the track of it loops for more than 4-5 times.

Tracepoint is an awesome feature of Visual Studio and it is available since Visual Studio 2005. It allows you to write the values in output window without even stopping at any point or you can stop it after the loop and see how the loop progressed based on your needs. I recently started using it and found is very useful. I am sure it is relatively less used.

Let’s see an example. Here I have created a simple program which finds out the nth number in a fibonacci series. Lets see the code

Now I am going to set a tracepoint at line #41. To set up a tracepoint, one need to set up a breakpoint and right click on it which provides few options, then select Actions which opens window as

(In earlier versions of Visual Studio, the options was named as Choice which is Actions as mentioned above)

Here I have written i={i} => result={result} . The values insde {} are the variable names in the program and the value of these variables will be printed.

The messages will be logged in output window. See here the check box Continue Execution which is self explanatory. If you uncheck this then the breatpoint would be hit as normal and pause the execution. So lets run the program and see the output window

I have provaide value 7. Here you can see that the value got printed here for each loop iteration. This is quite useful if number are pretty high.

Debugging is also get tricky in case mutli-threading and asynchronous programming scenarios which is pretty common nowadays.

There are few others pseudo variables available which can be used display various other useful information as

Hope you have enjoyed the post.

Cheers,
Brij

How to know the version of MVC of an Existing Project

Hello All,

This is one of the common questions which we see often in various forums. Even I have struggled to find the exact version of the MVC earlier. It becomes more tricky as Micrososft releases new MVC versions at regular interval. Earlier each new release was a major release with release number like MVC 1, MVC 2, MVC 3, MVC 4,MVC 5 but recently we see new releases with minor version like MVC 5.1, MVC 5.2 and even now with build number like the upcoming one ASP.NET MVC 5.2.4 (while previous one 5.2.3). It also become more problematic sometimes when we upgrade the mvc version.

Note – The version of a software is normally denoted by four number separated by dots as x.x.x.x which is as Major.Minor.Build.Revision.

There are many ways to find the specific version. We will discuss few common ones here

1- The simplest way to open Web.Config file and look for System.Web.Mvc, you could see similar as

Here 5.2.3 is the current version.

2- We can check the references in the solution explorer, find out the System.Web.Mvc, right click on it and select properties as

3- If your project contain packages.config (normally every project has it), then we can find the version from here easily.     Search for Microsoft.AspNet.Mvc and you should find something as

4- We can get the MVC version programatically based on the need as

5- There is a nuget package available which provides lots of useful information named MVCDiagnostics which adds a     page  named mvcdiagnostics.aspx which displays other useful information along with MVC version. This package could be   very useful if you are upgrading to new version and facing issues. The page looks as

I have not included the complete page for brevity but lot more details are availble on this page.

Package can be installed from here

This is quick post on of the common questions. Hope you find it useful.

Cheers,
Brij