<h4>A dive into Reflection in .NET — learning some of it’s popular use-cases.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PLjHppYR0SAWhO2d" /><figcaption>Photo by <a href="https://unsplash.com/@arvind_jay_v?utm_source=medium&amp;utm_medium=referral">Aravind V</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Objectives</h3>After reading this article, readers should be able to<ol><li>Define what Reflection is and know what it can be used for.</li><li>Know the difference between System.Type objects and type(s).</li><li>Comfortably use Reflection to get the Type of an object or a type.</li><li>Understand how to interact withType objects.</li><li>Use Reflection to access custom Attributes.</li></ol><h3>What is Reflection</h3>First, let’s get the obvious question out of the way.Reflection is the process by which we can get System.Type instances — which can then be used to describe assemblies, types and modules or even invoke methods and access variables of their target objects. Reflection also allows us to access the Attributes of our objects and their data.Straight away, we see that where we are using Reflection, we would also need the System.Type, so we need to add the following lines to the top of our .cs file.<pre>using System; using System.Reflection;</pre><h3>Difference between System.Type and type</h3>Before we move forward, it is important to be clear on what System.Type is, and how it differs from type.To paraphrase <a href="https://docs.microsoft.com/en-us/dotnet/csharp/fundamentals/types/">the official documentation on C# types</a>, each variable or constant in C# has a type (string, int, float, etc). Each method also takes in and returns parameters and values of known type. There are several categories of the type; ranging from <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/built-in-types">builtin types</a> (ex. string, long, bool), to <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types">value types</a> (ex. struct and enum) and <a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/reference-types">reference types</a> (ex. class, interface, delegate and record).System.Type on the other hand, provides us with methods through which we can reflect on objects, variables and constants, regardless of their type.<h3>Getting the System.Type</h3>There are two ways we can get the System.Type object, depending on whether we are getting that of a type or an object.<h4>Getting System.Type from an object</h4>In order to get the System.Type instance of an object, we use the GetType() method of the object.<pre>namespace MyProject; public class Example { public static void Main(string[] args) { Example example = new(); Type exampleType = example.GetType(); Console.WriteLine(exampleType); // MyProject.Example } }</pre>We can also use it to retrieve the System.Type instance, when the type is to be inferred at compile time (variables of type var).<pre>var a = 10; Console.WriteLine(a.GetType()); // System.Int32</pre><h4>Getting System.Type from a type</h4>Alternatively, if we wish to get the System.Type instance of a type, we use typeof.<pre>namespace MyProject; public class Example { public static void Main(string[] args) { Type exampleType = typeof(Example); Console.WriteLine(exampleType); // MyProject.Example } }</pre><h4>Differences between GetType and typeof</h4>We have seen two different ways of obtaining the System.Type instance of objects and types respectively. Let’s take a deeper look at the contrast between the two approaches.<ol><li>.GetType() is done at run time, while typeof is done at compile time.</li><li>.GetType() is only used to get the System.Type of an object instance, while typeof retrieves the System.Type of a type.</li></ol><h3>Common Use Cases of Reflection</h3>At this stage, we are comfortable using Reflection to retrieve the System.Type instance of objects and types. Now we are going to explore and learn about the ways we can use System.Type and what we can achieve with Reflection.Some of the more common use cases of Reflection include<h4>Getting Assembly information</h4>One of the most common use cases of Reflection in C# is actually getting the assembly of a particular instance.<pre>Console.WriteLine(typeof(int).Assembly); // System.Private.CoreLib, Version=6.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e</pre><h4>Knowing an object’s actual Type</h4>Sometimes in development, we use object-typed variables so that we have more generic and dynamic variables to work. However, this often comes at the cost of being able to access the methods, variables and properties.<pre>namespace MyProject; public class Human { public Human(string name) { Name = name; } public string Name { get; } public void SayHello() { Console.WriteLine($&quot;Hello, I am {Name}! Nice to meet you.&quot;); } } public class Example { public static void Main(string[] args) { object alex = new Human(&quot;Alex&quot;); Console.WriteLine(alex.Name); } }</pre>This would give use the following error at compile time:<figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*X-eGFhEkPqlOSOpUUwXVuw.png" /></figure>We can take the easy way out of casting the object-typed variable into the type we wish to interact with.Alternatively, using Reflection, we can retrieve the System.Type and then interact with that more easily and fluently.<pre>public class Example { public static void Main(string[] args) { object alex = new Human(&quot;Alex&quot;); Type alexType = alex.GetType(); // Get the property and method info from the Type PropertyInfo alexNameProp = alexType.GetProperty(&quot;Name&quot;); MethodInfo methodInfoProp = alexType.GetMethod(&quot;SayHello&quot;); // Retrieve the value or invoke the method on an instance Console.WriteLine($&quot;From {alexNameProp?.GetValue(alex)}&quot;); methodInfoProp?.Invoke(alex, new object[] { }); } }</pre>Looking at the example above, you would notice that after we retrieved the PropertyInfo alexNameProp and the MethodInfo methodInfoProp, we needed to pass a reference of the instance from which the Type was obtained (ie. alex). This stems from the fact we have walked up the hierarchy, from the instance alex up to its classType, hence the need for an instance on which to act upon.<h4>Getting the Type Arguments supplied to an object</h4>Consider a simple Dictionary mapping string to int<pre>Dictionary&lt;string, int&gt; nameAgeMap = new() { { &quot;Ade&quot;, 10 } }; Type nameAgeMapType = nameAgeMap.GetType();</pre>We can use the method GetGenericArguments to get the types arguments supplied to the Dictionary declaration.<pre>Type[] typeArgs = nameAgeMapType.GetGenericArguments(); foreach (Type tParam in typeArgs) { Console.WriteLine($&quot;Type Argument: {tParam}&quot;); } // Type Argument: System.String // Type Argument: System.Int32</pre><h4>Retrieving data from Attributes using Reflection</h4>We can obtain the data stored in Attributes by using the Reflection method GetCustomAttribute found in System.Type. Take for example, we have a custom Attribute called Nationality .<pre>public class NationalityAttribute : Attribute { public string country; public NationalityAttribute(string country) { this.country = country; } }</pre>Which we want to use on our Human class, for the sake of clarity, let’s define it again below.<pre>public class Human { public Human(string name) { Name = name; } public string Name { get; } }</pre>We could use Reflection to get the data from the Attribute called Nationality just like in the method SayHello below.<pre>[Nationality(&quot;Australia&quot;)] public class Human { ... public void SayHello() { Type thisType = this.GetType(); Attribute _attr = thisType.GetCustomAttribute( typeof(NationalityAttribute)); NationalityAttribute natAttr_ = (NationalityAttribute)_attr; Console.WriteLine($&quot;Hello, my name is {Name}! I come from {natAttr_?.country}&quot;); } }</pre>The first thing we did in the example above, is to get the System.Type value of the Human object. Next, we used Reflection to get the attribute of type NationalityAttribute attached to it. It’s important to note that the GetCustomAttribute method returns a value of type Attribute and not the type passed to it as an argument. Finally, we casted the value of type Attribute into NationalityAttribute and we are able to interact with the attribute.We could also access all Attributes of an object by invoking the GetCustomAttributes method of the Attribute class on a Type.<pre>Type humanType = typeof(Human); foreach (Attribute attr in Attribute.GetCustomAttributes(humanType)) { Console.WriteLine($&quot;Attribute {attr}&quot;); }</pre><h3>Summary</h3>Reflection is not something talked about a lot in .NET, though it could be really useful and applicable in so many different ways — few of which we explored in this article.If you found this article, clap, share and subscribe.<a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a>Till next time!<img alt="" height="1" src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=56ba1d3d1f22" width="1" />

A dive into Reflection in .NET — learning some of it’s popular use-cases.

Contents

Understanding Reflection in .NET within 5 minutes.

c-sharp-programming

dotnet

People also read