C# Reflection

C# Reflection is a mechanism to inspect, manipulate and interact with type information at runtime. By using the System.Reflection namespace, you can obtain metadata about types, methods, fields, properties, events, and attributes in your code. It is especially useful in scenarios where you need to interact with types and their members dynamically at run time, such as in late binding or plugin architectures.

Reflection can be used in a different ways. Here are a few examples to explain some of the basic uses of c# reflection.

1. Retrieving type information using `typeof`

   // get the type of a class using typeof
   Type myType = typeof(MyClass);
   
   // print the name of the class to the console
   Console.WriteLine("Class name: " + myType.Name);
   
   
   // print the name of the assembly containing the class
   Console.WriteLine("Assembly name: " + myType.Assembly.GetName().Name);
   

2. Retrieving type information using an instance of a class

   // create an instance of the MyClass class
   MyClass myObject = new MyClass();
   
   // get the type of the object using GetType()
   Type objectType = myObject.GetType();
   
   // print the name of the class to the console
   Console.WriteLine("Class name: " + objectType.Name);
   

3. Retrieving the properties of a class using reflection

   // get the type of a class using typeof
   Type myType = typeof(MyClass);
   
   // get the properties of the class
   PropertyInfo[] properties = myType.GetProperties();
   
   // iterate over the properties and print their names to the console
   foreach (PropertyInfo property in properties)
   {
       Console.WriteLine("Property name: " + property.Name);
   }
   

4. Invoking a method of a class using reflection

   // get the type of a class using typeof
   Type myType = typeof(MyClass);
   
   // create an instance of the class
   MyClass myObject = new MyClass();
   
   // get the method information using reflection
   MethodInfo method = myType.GetMethod("MyMethod");
   
   // invoke the method on the object
   method.Invoke(myObject, null);
   

   Another way to do the same, but using Activator.CreateInstance method to create class instance.

   using System;
   using System.Reflection;
   
   class MyClass
   {
       public void MyMethod()
       {
           Console.WriteLine("Hello, Reflection!");
       }
   }
   
   class Program
   {
       static void Main()
       {
           Type myType = typeof(MyClass);
           MethodInfo myMethod = myType.GetMethod("MyMethod");
           object myInstance = Activator.CreateInstance(myType);
   
           myMethod.Invoke(myInstance, null);
       }
   }
   

5. Invoke a method with parameters using Reflection

   using System;
   using System.Reflection;
   
   class MyClass
   {
       public void PrintMessage(string message, int repeat)
       {
           for (int i = 0; i < repeat; i++)
           {
               Console.WriteLine(message);
           }
       }
   }
   
   class Program
   {
       static void Main()
       {
           Type myType = typeof(MyClass);
           MethodInfo myMethod = myType.GetMethod("PrintMessage");
           object myInstance = Activator.CreateInstance(myType);
   
           object[] parameters = { "Hello, Reflection!", 3 };
           myMethod.Invoke(myInstance, parameters);
       }
   }
   

Reflection offers several benefits:

1. Dynamic loading and interaction with types: Reflection enables you to instantiate types, invoke methods, and access fields and properties at runtime, without knowing their names at compile time..
2. Extensibility and plugin architectures: Reflection allows you to load and interact with types from external assemblies, which is useful for creating extensible applications.
3. Inspection of metadata: Reflection provides access to type information, such as members, interfaces, and attributes, which can be useful for generating documentation or implementing serialization and deserialization.

Reflection has some disadvantages:

1. Performance: Reflection can be slow, especially when invoking methods or accessing fields and properties, as it bypasses compile-time optimizations.
2. Security: Reflection can potentially expose sensitive information or allow unauthorized access to types and their members.
3. Maintainability: Reflection-based code can be harder to understand and maintain due to its dynamic nature.

Reflection in C# can be significantly slower than direct method calls or field access, as it involves runtime type resolution, metadata access, and additional checks. The performance impact depends on the specific use case and the frequency of reflection operations.

C# Reflection involves the following (these are some, you should learn remaining in details, please consult official documentation) :

1. System.Reflection namespace: Provides classes for inspecting and interacting with types and their members.
2. System.Type: Represents type information at runtime.
3. Loaded assemblies: Contains classes, interfaces, value types, and other types that can be accessed using reflection.
4. MemberInfo objects: Represent information about type members, such as constructors, methods, fields, properties, and events.
5. System.Reflection.Emit namespace: Enables the creation of dynamic types, methods, and assemblies at runtime.

Attributes are a way to attach metadata to your code elements (such as classes, methods, or properties) at compile time. Reflection, on the other hand, allows you to access and manipulate this metadata at runtime. Using reflection, you can also inspect attributes and retrieve their values.

Example:

using System;

[AttributeUsage(AttributeTargets.Class)]
public class MyAttribute : Attribute
{
    public string Description { get; set; }

    public MyAttribute(string description)
    {
        Description = description;
    }
}

[MyAttribute("Sample class")]
class MyClass
{
}

class Program
{
    static void Main()
    {
        Type myType = typeof(MyClass);
        MyAttribute attribute = (MyAttribute)Attribute.GetCustomAttribute(myType, typeof(MyAttribute));
        Console.WriteLine("Attribute Description: " + attribute.Description);
    }
}

This code demonstrates how to use custom attributes and reflection in C#. The code defines a custom attribute called "MyAttribute" that can be applied to a class. The attribute has a single property called "Description", which can be set when the attribute is applied to a class.

The code then defines a class called "MyClass" and applies the "MyAttribute" attribute to it with the description "Sample class".

In the "Main" method of the program, the code uses reflection to get the "Type" object for the "MyClass" class. It then uses the "Attribute.GetCustomAttribute" method to retrieve the "MyAttribute" attribute from the "MyClass" type.

Finally, the program outputs the value of the "Description" property of the "MyAttribute" attribute, which in this case is "Sample class".

At runtime, C# Reflection allows you to examine and interact with types and their members, which is a powerful feature. It offers various advantages, such as enabling dynamic loading and interaction with types, supporting extensibility and plugin architectures, and providing access to metadata. However, it also has some complications, such as performance overhead and security concerns. By understanding the concepts and components of reflection and using it judiciously, you can harness its full potential to build flexible and extensible applications.

You can read more about C# what is Reflection and C# Attributes from other articles we have in our website.