C# 6.0 and 7.x posts links

Hello All,

There are rapid changes to C# language recently. Although these are very useful in writing cleaner, concise, less repetitive and performance oriented code, I see very less usage of these in our day to day coding. So I thought of writing these features as blog posts to learn myself and share with others. In this post I am just listing down the links of my earlier C#6.0 and C# 7.x blog posts so that it is easily available. Do let me know if there is any important feature that I missed which could be useful in our day to day coding.

C# 6.0 features

C# 7.X features

Hope you’ll enjoy these posts and able to use these in your day to day development.

Cheers,
Brij

Advertisements

Expression-bodied Members in C#

Expression-bodied members are one of the shiny features of C# 6.0 which allows us to write the implementation of a member in more readable and concise format. We can use the expressions as a definition of the members instead of using the statement block. The format of the expression is as

var=> expression

This is also called lambda expressions and => is called lambda operator. In C# 6.0, we can use this feature with methods and properties. Lets see few examples

Properties: Instead of using the normal getter, we can use expressions with lambda operators as mentioned.


// Normal way
public string FullName
{
    get { return string.Format("{0} {1}", FirstName, LastName); }
}

// Using Expression (C# 6.0)
public string FullName => string.Format("{0} {1}", FirstName, LastName);

// Above code can be more consize using string interpolation
public string FullName =>$"{FirstName} {LastName}";

If you are not aware of String Interpolation, you can refer one of my previous post here.

Methods : Similar to properties, C# 6.0 also allows us to use expressions while writing methods which returns values to the caller.


// Normal way
public string GetFullName(string firstname, string middleName, string lastName)
{
    return middleName == null ? $"{firstname} {lastName}" : $"{firstname} {middleName} {lastName}";
}

// Using Expessions 
public string GetFullName(string firstname, string middleName, string lastName) => middleName == null ? 
             $"{firstname} {lastName}" : $"{firstname} {middleName} {lastName}";

Limitation: There is a limitation of expression bodied members.We can have just single statement in the expression and statement blocks {} are not allowed. In my above example, I used the ternary operator conditional logic instead of using if statement block.

As we can see C# 6.0 added the capability for methods and read only properties, C# 7.0 added more power to this feature and now we can use expressions in constructors, set accessors in properties, indexers and finalizers. Let’s take a look

Properties: We saw earlier enhancements for Property which was similar to get accessor

private string _name;
public string Name {
    get => _name;
    set => _name = value;
}

Here this is a very simple example and in this scenario, I would like to prefer the Auto propery as below

public string Name { get; set; }

However in my earlier example where I was returning FullName after concatenating two strings, there it is better suited. So when you are doing some smaller operations as well in your property then it is better choice.

Constructor: We can leverage the expression with the constructors as well. Let’s see

// Earlier
public Person(string name)
{
    this.Name = name;
}

// With C# 7.0
public Person(string name) => this.Name = name; 

As mentioned earlier that statement block can’t be used here. So say if I have multiple parameters to pass so I can use another C# 7.0 features: ValueTuple and Destructors.

public Person(string firstName, string lastName) => (FirstName, LastName) = (firstName, lastName);

I wrote some time back on ValueTuples and Deconstructors, you can take a look.

Finalizers: We can use expressions in finalizers as well. Let’s see

// Earlier
~Person()
{
    Console.WriteLine("Person's destructor");
}

// Using Expressions
~Person() => Console.WriteLine("Person's destructor");

There are many new features that got intrudocuced in C# 6.0 and C# 7.X (7.0, 7.1, 7.2) if these are used together, can provide lot of value. The whole idea is write cleaner, concise and more performant code so that the focus is more on business logic.

Hope you are enjoying the enhancements.

Cheers
Brij

Error: CS0619 Span is obsolete

Recently I was exploring various new features of C# 7.x and recently I thought of looking into one cool feature Span but faced hard time to start. So to start with it, one need to install the nuget package System.Memory as

Make sure, you have Include Prerelease check box selected. After that we need to include System.Memory namespace. Once I wrote my first variable as

Upon building the project, I got the following error

I thought something as new as span, how come this be obsolete. I spent some time googling it with no specific result.
I looked my Visual Studio version which Visual Studio Enterprise 2017 v 15.4.2. I thought to update the same as there were few minor releases after that. After updating it to the latest available v15.6.2, I tried again and this time no error.

Initial error was not intuitive enough and updating Visual Studio, i consider last thing unless it is mentioned somewhere.

If you facing similar issue, this may be helpful to you as well.

Thanks
Brij

Read-Only Structs: C# 7.2

C# supports two basic types : Value Type and Reference Type. The main difference between them where they get created: Value Types gets created in stack while Reference type in Heap. Other key difference, for ValueType whenever a parameter is passed as an argument, a copy gets created and passed while for reference types, refernce of the same onstance gets passed. There is another type called – Nullable Type but actually it’s a wrapper over value type. I wrote a post on it, you can have a look here.

All the Value Types internally inherits System.ValueType. Struct is also a ValueType which inherits same.

It’s a good idea to make struct immutable, it means once it is initalized, it cannot be modified. System.DateTime is an immutable Value Type. It provides many static methods but it always returns a new instance.

To make a struct immutable, the simple way to make all the members readonly and initializ these values via parameterized constructor. It’s members should be exposed via getter fields.

Let’s see an example

public struct Person
{
    public string FirstName { get; }

    public string LastName { get; }

    public int Age { get; }

    public Person(string firstName, string lastName, int age)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
        this.Age = age;
    }
}

Above struct is immutable as there is no way to modify the initialized variable.

Read-Only structs:

Prior to C# 7.2, to create an Immutable value type, we had to write the struct in a way so that it doesn’t allow an update as in above example. If few fields are left without marking readonly/const unknowingly then it wont work as expected. C# 7.2 allows us to add readonly modifier before struct which makes sure thatg all the members are read only. If any member doesn’t, it will throw an error. Above struct can be marked as read only as

public readonly struct Person
{
    public string FirstName { get; }

    public string LastName { get; }

    public int Age { get; }

    public Person(string firstName, string lastName, int age)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
        this.Age = age;
    }

}

One important thing, the parameterized constructor should be used to create the instance always else in case of using parameterless constructor use, the member would be set to default value which cannot be ever changed and we probably won’t want this. We cannot make parameter less private for struct in C# and even if there is a way we can bypass that. We can have some validate method which should be fired before using that struct’s memebers. I wont discuss this in details here.

Read-only struct provides framework support to write readonly struct and help us to avoid any unintended modification. In my previous post, I discussed about In modifier, it also can be used while passing any immutable object. These changes like ref, out, in etc in .NET framework got developed to make low level programming simpler and faster. Few more changes, we will be discussing in coming posts.

Note: If you are not sure how to use X# 7.2 (7.x) in your project, you may have a look on one of my previos post here.

Hope you enjoyed the post.

Cheers
Brij

Using Deconstructors in C# 7.0

This is another awesome feature that got introduced with C# 7.0 which can be helpful in many scenarios while consuming various objects. Deconstruction is mostly discussed with another new feature System.ValueTuple but it can be used with other custom type as well. I have also discussed it in briefly in ValueTuple post at the link below. I will advise to go through that first before starting here.

How to use the new ValueTuples : A C# 7.0 feature

What is Deconstruction

It is a process of splitting an instance’s (value types and reference types) value into multiple parts and assigning them to new variables. Like, I mentioned that it is extremely useful with the Tuples which contains a set of values but can be used with other types.

How to use Deconstruction

We can leverage it in our custom classes, structs or interfaces. We need to implement Deconstruct method, which returns void and each deconstructed value should be added as out parameter in the method signature. We can have multiple overridden Deconstruct method based on the requirement. Let’s see an example

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

    public string MiddleName { get; set; }

    public string LastName { get; set; }

    public int Age { get; set; }

    public Person(string fName, string mName, string lName, int age)
    {
        FirstName = fName;
        MiddleName = mName;
        LastName = lName;
        Age = age;
    }
    public void Deconstruct(out string fName, out string lName)
    {
        fName = FirstName;
        lName = LastName;
    }

    public void Deconstruct(out string fName, out string lName, out int age)
    {
        fName = FirstName;
        lName = LastName;
        age = Age;
    }
}

Here we can see that I have provided two Deconstruct methods, one with two out parameters: fName, lName and other with three : fName, lName, age.

Person p = new Person("Brij", "Bhushan", "Mishra", 32);

//(string firstName, string lastName) = p;
// OR
var (firstName, lastName) = p;

Console.WriteLine($"Person Details: First Name: {firstName}, Last Name: {lastName}");


(string firstName, string lastName, int age) = p;

Console.WriteLine($"Person Details: First Name: {firstName}, Last Name: {lastName}, Age: {age}");

Here I created the instance of Person with all the details. Then in first deconstruction, we got the first name and last name which calls the first Deconstruct method of the class which has two out parameters. Note that we have two ways of deconstruction. First we explicitly declare the type of each field inside parentheses (commented out) and another, using var keyword so that C# infers the type of each variable. Similarly later, second Deconstruct method is called which deconstructs it in three variables. It can be really useful when we have a class with numerous properties, fields and most of the time, we need only few there we can use the Deconstruct methods.

Similar to ValueTuples, we can use discards here as well. To discard a variable of Deconstruct method, we can use underscore (_) as

Person p = new Person("Brij", "Bhushan", "Mishra", 32);
(string firstName, _ , int age) = p;

Console.WriteLine($"Hello {firstName}, your age is {age}");

Deconstruction use Extension method

There could be scenarios where you want to this feature but its an existing class where changes are not possible (like some third party classes, classes own by different team or even framework classes), there we can add this as an extension method. Lets assume that Person class doesn’t have Deconstruct methods and we can add it as an extension method as

public static class DeconstructionExtensions
{
    public static void Deconstruct( this Person p, out string fName, out string lName, out int age)
    {
        fName = p.FirstName;
        lName = p.LastName;
        age = p.Age;
    }
}

It will work in the same way as earlier.

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

Thanks
Brij

Ref and Out improvements in C# 7.0

If you have been observing last few releases of C#, the key focus of C# language team is to improve the developer productivity by reducing the repetitive/common code and performance of the application. First one, helps a lot in writing cleaner and concise code so it mainly contains logic instead of number of lines for null check etc.

ref and out keywords are available with C# since long and very useful in many scenarios. These were serving the purpose quite beautifully but there were few improvements in C# 7.0 which makes it more attractive. In this post, I am not going to discuss the basics of these keywords detail but mainly focus on the improvements in C# 7.0.

Ref keyword – This keyword is used to pass the parameter by reference (even if it is value type) to a method. When we pass the parameter by reference, any change that takes place in the called method also reflects in calling method. ref keyword should be used by in calling method while passing the parameter and in the called method as well. Also unassigned variable cannot be passed as well. Lets see a quick example

static void Main(string[] args)
{
    Point p;
    p.x = 10;
    p.y = 20;

    UpdateCoordinates(ref p);

    Console.WriteLine($"Point coordinates x : {p.x}, y : {p.y}"); // Output: Point coordinates x : 20, y : 40

    Console.ReadKey();
}

static void UpdateCoordinates(ref Point p)
{
    p.x = 20;
    p.y = 40;
}

public struct Point
{
    public int x, y;
}

Here Point is a value type and it is passed using ref keyword. Here the variable gets updated in the called method and it shows 20 and 40 in output.

Note: ref keyword can be used with reference types as well. You can refer one of my previous posts for details here 

C# 7.0 Enhancements :

As in the example above, the values are passed by reference in the method but what about returning the values by reference. For this, there were two enhancements introduced

1- Ref Returns : For this, we need to add ref keyword after return statement in a method and before the return type in the method signature. This feature can be used only in Class (not structs). Let see the Point class as

public class Point
{
    private int x, y;

    public Point(int a, int b)
    {
        this.x = a;
        this.y = b;
    }
    public ref int GetX()
    {
        return ref this.x;
    }

    public ref int GetY()
    {
        return ref this.y;
    }
      
    public void Display()
    {
        Console.WriteLine($"Point coordinates x : {x}, y : {y}");
    }
}

Here I added two methods GetX and GetY which returns x and y by reference. ref keyword also got added with method signature as well.

2- Ref Locals: To store a reference variable (ref), returned by a method, the local variable should also be added with ref keyword before the type and adding the ref keyword before the method call. Now the local variable contains the value by reference and has the ability to change the value of variable which will reflect in the original variable as well. We can call the method without using the ref keyword which will behave as normal method call and the returned value will be a copy of the value.

static void Main(string[] args)
{
    Point p = new Point(10, 20);

    ref int i = ref p.GetX();
    i = 50;

    p.Display(); // Output: Point coordinates x : 50, y : 20

    int j = p.GetY();
    j = 100;

    p.Display(); // Output: Point coordinates x : 50, y : 20

    Console.ReadKey();
}

Initially the values of x and y are 10 and 20. We got the variable x by refernce and updated it to 50 using variable i which is reflected in output. We also received the value of y without using ref which creates a copy of the variable and updating it doesn’t affect the instance p.

It is a really nice feature in scenarios where the values are required to be updated at different places. This also can be when we have a collection of values and few of the items can be updated by the caller method based on the need.

Enhancements in Out parameter: There is a small enhancements in out parameter usage. Earlier out parameter is used as

static void Main(string[] args)
{
    int age;
    string name = GetUserDetails(out age);
    Console.WriteLine($"name : {name}, age : {age}");

    Console.ReadKey();
}

public static string GetUserDetails(out int age)
{
    age = 32;
    return "Brij";
}

Now after enhancement, we dont need to declare the variable first, instead we can direcly declare in the paarmeter as well as

static void Main(string[] args)
{
    //int age;
    string name = GetUserDetails(out int age);
    Console.WriteLine($"name : {name}, age : {age}");

    Console.ReadKey();
}

Although this is a small enhancement but makes more sense.

Hope you enjoyed the post and will be able leverage these enhancements in your day to day coding.

Cheers,
Brij

How to use the new ValueTuples : A C# 7.0 feature

Tuples are one of the awesome features of C# which was initially introduced with .NET 4.0. Although it is less used but it become very handy when we need to return multiple values from a function. We have another option to use out operator but it is not recommended due to various reasons. I am not going to discuss it in this post. Tuple is a static class under namespace System which implements a Factory pattern to create the instances of Tuples. It has a Create method with eight overloads which allows us to have 8 elements in a Tuple. Also, we can have nested tuples as well.

There were few issues with System.Tuple. It is a reference type so even if you are returning few values type elements , the instance gets created on heap, means adding pressure on Garbage Collector. It doesn’t allow to provide a name to the elements, instead we have to refer it as item1, item2.. etc. Also, the way we used to create Tuple is also quite verbose.

Tuple in C# 7.0

C# 7.0 introduces System.ValueTuple as a new language feature, which resolves the problems mentioned above and provides few more additional features. And Yes, it has the power of Value Type so it removes the GC overhead of the old tuple.

Note: ValueTuple is available as indepedent nuget package. You can install it from here.

Lets see few examples of new Value Tuples,

Tuple Literals

Tuple literal is a comma separated list of literal (of various types), surrounded by parenthesis.

static void Main(string[] args)
{
    // Tuple Literals
    var tpl = (1, 2);
    var author = ("Brij", 32, "https://codewala.net/");
}

public (string, int, string) Author { get; set; } = ("Brij", 32, "https://codewala.net/");

Here we can see that creating Tuple is now a simple assignment operation. Also we can have different types in a Tuple which helps in combining various set of information in a tuple based on the need.

Using Tuples as Return Type

We can use value tuple as return type and the syntax looks so simple as


var author = GetAuthor();

Console.WriteLine($"Author Details: Name: {author.Item1}, Age: {author.Item2}, BlogURL : {author.Item3 ?? "URL not available" } ");

private static (string, int, string) GetAuthor()
{
    string name = "Amit Kumar";
    int age = 33;
    return (name, age, null);
}

Naming the Tuple Elements:
Yes, we can name the tuple elements and this also provides the intellisense support. This is one of the best improvements. We can write the above code as

var author = GetAuthor();
WriteLine($"Author Details: Name: {author.name}, Age: {author.age}, BlogURL : {author.url ?? "URL not available" } ");

private static (string name, int age, string url) GetAuthor()
{
    string name = "Amit Kumar";
    int age = 33;
    return (name, age, null);
}

We can give names in tuple literal as well

var author = (name: "Brij", age: 32, url: "https://codewala.net/");      
Console.WriteLine($"Author Details: Name: {author.name}, Age: {author.age}, BlogURL : {author.url ?? "URL not available" } ");
// Or we can also write as
(string name, int age, string url) author = ("Brij", 32, "https://codewala.net/");

Let’s move to another exciting feature

Value Tuple Deconstruction

Value tuple allows us deconstruct the tuple and access the elements as a local variable. We need to assign a tuple to variable surrounded by parenthesis.  Broadly, it can be done in three ways

  • Providing the types of each element in parenthesis.
  • Using var keyword outside the parenthesis (it is applied to each variable).
  • Or using existing variables

Lets see the examples


// First Option - Providing the type of each element. var is also allowed.
(string authorname, int age, var blog) = GetAuthor();
Console.WriteLine($"Author Details: Name: {authorname}, Age: {age}, BlogURL : {blog ?? "URL not available" } ");

// Second Option - Using var outside of the parenthesis
var (authorname, age, blog) = GetAuthor();
Console.WriteLine($"Author Details: Name: {authorname}, Age: {age}, BlogURL : {blog ?? "URL not available" } ");

// Third option - Using existing variables
string authorname = "Brij";
int age = 32;
string blog = "https://codewala.net/";

(authorname, age, blog) = GetAuthor();
Console.WriteLine($"Author Details: Name: {authorname}, Age: {age}, BlogURL : {blog ?? "URL not available" } ");			

Now it may happen that you are not sure about all the elements or want to discard few , you can use underscore (_) as

var (authorname, age, _) = GetAuthor();
Console.WriteLine($"Author Details: Name: {authorname}, Age: {age}");

Last thing, as we have now System.Tuple and System.ValueTuple both, ValueTuple provide a nice extension method as ToTuple() to convert it to System.Tuple.

C# 7.1 Enhancements: 

There are a small enhancement in C# 7.1 which can save few keystrokes as now elements names are inferred from the variables. Let’s see the example

// Earlier
string name = "Brij";
int age = 32;
string blog = "https://codewala.net/";
var author = (name: name, age: age, blog: blog);

// With C# 7.1 
string name = "Brij";
int age = 32;
string blog = "https://codewala.net/";
var author = (name, age, blog); // Element names would be - name, age, blog

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

Cheers,
Brij