C# Reflection Example

Reflection is the process of examining and manipulating the structure and behaviour of program at runtime.With Reflection anybody can determines types, methods, properties, Constructor and other members of your program dynamically, without necessarily knowing them at compile time. Reflection provides a powerful way to interact with types and objects in a flexible manner.you can use reflection to get information about events defined within a type, such as their names, event handlers, and other metadata.

The below are some common uses of reflection in C#:

  • Check Types:

    Reflection can be used to get information about types at runtime, such as their properties, methods, fields, and attributes.

  • Creating Instances at RunTime:

    You can use reflection to create instances of types (properties, methods, fields, and attributes) at runtime, even if you only know the type (properties, methods, fields, and attributes) name at runtime.

  • Methods and Properties Invokation at RunTime:

    Reflection can be used for methods and properties invokation at runtime, This is specially useful when you don't know the member names at compile time.

  • Getting and Changing Fields:

    You can use reflection to get and chang the fields of objects at runtime.

  • Inspecting Attributes:

    Reflection can be used to inspect the attributes applied to types, fields, methods, properties, constructor etc and can apply a necessary action based on them.

  • C# Reflection Example

    using System;
    using System.Reflection;
    class FruitClass
    {
    public string fruitName { get; set; }
    public void GetFruitName()
    {
    Console.WriteLine("Name of Fruit is = " + fruitName);
    }
    }
    public class CSharpProgram
    {
    public static void Main(string[] arge)
    {

    // Get assembly dynamically

    Type t = typeof(System.String);
    Console.WriteLine(t.Assembly);
    Console.WriteLine(t.FullName);
    Console.WriteLine(t.BaseType);
    Console.WriteLine(t.IsClass);
    Console.WriteLine(t.IsEnum);
    Console.WriteLine(t.IsInterface);
    Console.WriteLine(t.Name);
    Console.WriteLine(t.Namespace);
    Console.WriteLine(t.Module);

    // Get the type dynamically

    Type fruitType = typeof(FruitClass);

    // Create an instance of the type dynamically

    object fruitInstance = Activator.CreateInstance(fruitType);

    // Access a property dynamically

    PropertyInfo propertyInfo = fruitType.GetProperty("fruitName");
    propertyInfo.SetValue(fruitInstance, "Mango, Reflection");

    // Invoke a method dynamically

    MethodInfo methodInfo = fruitType.GetMethod("GetFruitName");
    methodInfo.Invoke(fruitInstance, null);

    // Access the property value

    string propertyValue = (string)propertyInfo.GetValue(fruitInstance);
    Console.WriteLine("Property value: " + propertyValue);
    }
    }


    Output

    System.Private.CoreLib, Version=8.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e
    System.String
    System.Object
    True
    False
    False
    String
    System
    System.Private.CoreLib.dll
    Name of Fruit is = Mango, Reflection
    Property value: Mango, Reflection

  • Reflection in C# with Event Example

    Here in below code we have defined event. We have created an instance of the class and getting the type of the class, getting the event defined in the class and displaying information about each event, displaying information about the event handler delegate type.

    using System;
    using System.Reflection;
    class EventExample
    {
    public event EventHandler FruitEvent;
    public void OnMyEvent()
    {

    // Raise the event

    FruitEvent?.Invoke(this, EventArgs.Empty);
    }
    }
    class Program
    {
    public static void Main(string[] args)
    {

    // Create an instance of the class

    EventExample example = new EventExample();

    // Get the type of the class

    Type type = example.GetType();

    // Get the event defined in the class

    EventInfo[] events = type.GetEvents();

    // Display information about each event

    foreach (EventInfo evt in events)
    {
    Console.WriteLine($"Event Name: {evt.Name}");

    // Display information about the event handler delegate type

    Console.WriteLine($"Event Handler Type: {evt.EventHandlerType} ");
    }
    }
    }


    Output

    Event Name: FruitEvent
    Event Handler Type: System.EventHandlert

  • Reflection in C# with Enum Example

    Here in below code we have defined enum. In main method we are getting assembly dynamically and displaying the name of the enum, we are also getting enum values via reflection code. We are also displaying enum value name and underlying string value and getting the type dynamically. We have also created an instance of the type dynamically and accessing a enum dynamically.

    using System;
    using System.Reflection;
    enum FruitEnumName
    {
    Apple,
    Banana,
    Mango,
    Grape,
    Orange,
    Cherry,
    Kiwi
    }
    public class CSharpProgram
    {
    public static void Main(string[] arge)
    {

    // Get assembly dynamically

    Type enumType = typeof(FruitEnumName);

    // Display the name of the enum

    Console.WriteLine($"Enum Name: {enumType.Name}");
    Console.WriteLine(enumType.IsEnum);

    // Get enum values

    Array enumValues = Enum.GetValues(enumType);
    foreach (object value in enumValues)
    {

    // Display enum value name and underlying string value

    Console.WriteLine($"Name: {Enum.GetName(enumType, value)}, Value: {(object)value}");

    // Get the type dynamically

    Type fruitEnumType = typeof(FruitEnumName);

    // Create an instance of the type dynamically

    object fruitEnumInstance = Activator.CreateInstance(fruitEnumType);

    // Access a enum dynamically

    string enumInstance = enumType.GetEnumName(fruitEnumInstance);
    Console.WriteLine("Enum value: " + enumInstance);
    }
    }
    }


    Output

    Enum Name: FruitEnumName
    True
    Name: Apple, Value: Apple
    Enum value: Apple
    Name: Banana, Value: Banana
    Enum value: Apple
    Name: Mango, Value: Mango
    Enum value: Apple
    Name: Grape, Value: Grape
    Enum value: Apple
    Name: Orange, Value: Orange
    Enum value: Apple
    Name: Cherry, Value: Cherry
    Enum value: Apple
    Name: Kiwi, Value: Kiwi
    Enum value: Apple

Previous Next
Choose Your Options
RTL Version
Boxed Version
Want Sticky Header
Dark Verion
Purchase now $17
You will find much more options and styling in admin panel.
TOP