The Top Seven Least-Known, Yet Important, C# Features

Introduction

We could be an experienced programmer who has been coding since long in C#. Still, there are a few C# language features which we don’t use frequently and probably know very little about them. I have listed down 7 most underutilized features of C# in this article ahead. So, let's start.

What is Yield Keyword?

In my list, Yield gets the first position of unsung C# features. It maintains the state in the loop and returns back to the calling method and resumes with the previous state, i.e., Yield provides Stateful Iteration.

If you don’t understand this statement, don’t worry and don’t give up; you will be having a very good understanding of this in the next 2 minutes.

To understand that, let us explore this code and its explanation.

Use Case

Here, I want to print the employee names who are having a salary more than 20,000. I am using the in-memory collection.

Example

class Employee
{
    public string Name { get; set; }
    public int Salary { get; set; }
}

class Program
{
    static List<Employee> Employees = new List<Employee>
    {
        new Employee { Name = "Tom", Salary = 12000 },
        new Employee { Name = "Harry", Salary = 15000 },
        new Employee { Name = "Sam", Salary = 10000 },
        new Employee { Name = "Mike", Salary = 25000 },
        new Employee { Name = "Bob", Salary = 22000 },
        new Employee { Name = "Raj", Salary = 18000 },
    };

    static void Main(string[] args)
    {
        PrintData();
    }

    static void PrintData()
    {
        foreach (var emp in FilterWYield())
        {
            Console.WriteLine(emp.Name);
        }

        foreach (var emp in FilterSimple())
        {
            Console.WriteLine(emp.Name);
        }
    }

    static IEnumerable<Employee> FilterWYield()
    {
        foreach (var item in Employees)
        {
            if (item.Salary >= 20000)
            {
                yield return item;
            }
        }
    }

    static IEnumerable<Employee> FilterSimple()
    {
        List<Employee> emps = new List<Employee>();
        foreach (var item in Employees)
        {
            if (item.Salary >= 20000)
            {
                emps.Add(item);
            }
        }
        return emps;
    }
}

Code Explanation

For the simple implementation in FilterSimple() method, I have used a temporary collection (emps). When the condition (Salary >=20000) gets true, it adds that item to the this collection (emps) and at the end of execution of foreach loop, it returns that collection to caller methods PrintData() and prints the result.

Implementation with Yield is different. We do NOT need additional collection in FilterWYield(). In the foreach loop, it evaluates the condition and when the condition (Salary >=20000) is true, it returns the value to the caller method PrintData() and prints the result. Then, again, it comes back to FilterWYield() method and resumes the execution (Note here - it doesn't start, rather remembers the position in collection and resumes from there only). That is why it is called as Stateful Iteration.

This diagram explains the scenario in a better way.

As you can see here, for Tom, Harry, and Sam, the loop executes normally and checks from the condition which is false and execute next.

For Mike, the condition evaluates to true and then it passes the value to PrintData() where it prints the name of the employee as Mike. Now, it comes back to the collection and resumes where it had left, i.e., now it will execute the condition for Bob and again it is true and takes the data to PrintData() method and prints the name, Bob. It comes back to the collection and resumes execution of condition for Raj and condition fails and doesn't go to the PrintData() method and loop ends.

I hope with this, you understand the working on Yield and why it provides Stateful Iteration. For more details, please refer to this MSDN article.

What is String Interning?

When we assign a value to a string variable at run time, it creates a new instance of that. If we already have that value in memory, then also, it will create a new instance, instead of using that.

With string interning, we can ask the compiler to use the existing memory reference and abandon any other string variable having the same value.

In this article, I have explained everything from basic to the advanced level we need to know about string interning and how to use in your real time project.

What is Lazy<T>?