A Look at the Caller Info Attributes in C# 5.0

In C# 4.0 or earlier versions, to get the caller information at the called method the caller had to explicitly pass the information as a parameter or by some other means. In order to do that it had to use the Reflection classes that are available under the namespace System.Reflection.

Now C# 5.0 exposes a feature called Caller Info attributes in order to accomplish the task with ease. This article offers an insight about these attributes.

Caller Info Attributes

CallerInfo attributes are specifically designed to decorate the optional parameters of a method, which can then be used by the .NET runtime to inject the caller information. Below are some of the advantages of caller info attributes when compared to the traditional methods of passing the caller information.

These attributes are encapsulated under the namespace System.Runtime.CompilerServices.

What are they?

There are 3 caller info attributes that come along with C# 5.0 and they are:

Using Caller Info Attributes

In this section let us create a small application to demonstrate the usage of these CallerInfo attributes in C# 5.0. Create a console application and add the below mentioned code to Program.cs.

namespace CallerInfoAttributes
{
    class Program
    {
        static void Main(string[] args)
        {
            PrintCallerInformation();
 
            Console.ReadLine();
        }
 
        static void PrintCallerInformation([CallerLineNumber] int lineNumber = 0, [CallerFilePath] string filePath = "", [CallerMemberName] string memberName = "")
        {
            Console.WriteLine("Line number from where the call is made: {0}", lineNumber);
            Console.WriteLine("Filepath of the caller: {0}", filePath);
            Console.WriteLine("Member which is making the call: {0}", memberName);
        }
    }
}

When you execute the console application you will exactly see the Caller Info parameters that are being passed.

CallerMemberName – Specialty

The CallerMemberName attribute can be of some special use. For example if you want to decide the business logic based on the caller at runtime then CallerMemberName would help you. Below is a sample piece of code.

namespace CallerInfoAttributes
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 10;
            int j = 5;
            Add(i, j);
            Sub(i, j);
        }
 
        private static void Sub(int value1, int value2)
        {
            Compute(value1, value2);
        }
 
        private static void Add(int value1, int value2)
        {
            Compute(value1, value2);
        }
 
        private static void Compute(int value1, int value2, [CallerMemberName] string memberName = "")
        {
            if (memberName.Equals("Add"))
                Console.WriteLine("Sum = {0}", value1 + value2);
            else
                Console.WriteLine("Difference = {0}", value1 - value2);
        }
    }
}

Also if you are implementing the INotifyProperyChanged interface in your class, you would have been passing the member name as a hard coded string from the property setter while raising the PropertyChanged event. This can be avoided by using the CallerMemberName attribute.

The CallerMemberName would inject specific values based on the caller. Below is the list.

This is all I had to share about the Caller Info attributes of C# 5.0. Happy reading!