C# Reflection and Attributes

C# reflection is a powerful feature that allows developers to inspect and manipulate types, properties, methods, and other elements of code at runtime. It provides a way to dynamically interact with objects and classes, enabling the creation of flexible and extensible applications.

Example: Using Reflection to Get Type Information

using System;

public class Student
{
public string Name { get; set; }
public int Age { get; set; }
}

public static void Main()
{
Type studentType = typeof(Student);
Console.WriteLine(“Properties of Student class:”);

foreach (var property in studentType.GetProperties())
{
Console.WriteLine(property.Name);
}
}
In this example, we use reflection to get the properties of the Student class at runtime.

Attributes in C# are metadata that provide additional information about types, methods, or properties. They allow developers to add custom metadata to code elements, facilitating various functionalities and behaviors.

Example: Using Built-in Attribute

[Obsolete(“This method is deprecated. Use the NewMethod instead.”)] public void OldMethod()
{
// Old method implementation
}
In this example, we use the Obsolete attribute to mark the OldMethod as deprecated and provide a message for developers to use the NewMethod instead.

C# also allows developers to create custom attributes tailored to specific requirements, empowering applications with custom metadata.

Example: Creating a Custom Attribute

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] public class CustomAttribute : Attribute
{
public string Description { get; }

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

public class Example
{
[Custom(“This is a custom attribute example.”)] public void CustomMethod()
{
// Custom method implementation
}
}
In this example, we create a custom attribute named CustomAttribute that can be applied to methods, and then we apply it to the CustomMethod.