9.Reflection & Dynamic Features - aniketmulmule/web_Project GitHub Wiki

Here’s a deep dive into Reflection and Dynamic Features in C#, tailored for 8+ years of experience, with code examples, advanced use cases, and interview-level insights.

Reflection is a powerful feature in .NET that allows you to inspect and interact with metadata, types, assemblies, and members at runtime.

• Late binding (e.g., plug-in loading)

• Inspecting attributes and methods

• Creating objects dynamically

• Serialization frameworks

• Testing/mocking

Would you like:

• 📄 A PDF version of this for your study kit?

• 🧪 Practice exercises or quizzes?

• 🎯 Mock interview questions with sample answers?

Let me know — happy to prepare those!

Reflection is a powerful feature in .NET that allows you to inspect and interact with metadata, types, assemblies, and members at runtime.

• Late binding (e.g., plug-in loading)
• Inspecting attributes and methods
• Creating objects dynamically
• Serialization frameworks
• Testing/mocking

Type type = typeof(string);
Console.WriteLine(type.FullName); // System.String

foreach (var method in type.GetMethods())
{
    Console.WriteLine(method.Name);
}

Type t = Type.GetType("System.Text.StringBuilder");
object obj = Activator.CreateInstance(t);

MethodInfo method = t.GetMethod("Append", new[] { typeof(string) });
method.Invoke(obj, new object[] { "Hello" });

[Obsolete("Use NewMethod")]
public void OldMethod() { }

var method = typeof(MyClass).GetMethod("OldMethod");
var attr = method.GetCustomAttribute<ObsoleteAttribute>();
Console.WriteLine(attr.Message); // Use NewMethod

• Reflection is slower than direct access.
• Bypasses compile-time checking → runtime errors.
• Difficult to maintain and test.
• Use only where dynamic behavior is essential.

Introduced in C# 4.0 — runtime-bound type.

dynamic x = "hello";
Console.WriteLine(x.Length); // Works, but resolved at runtime

x = 123;
Console.WriteLine(x.Length); // Runtime error!

• Bypasses IntelliSense and compile-time type checks

• Useful for:

  • Interop with COM/JavaScript
  • Reflection-like scenarios
  • JSON/XML dynamic parsing

Allows you to add members at runtime.

dynamic obj = new ExpandoObject();
obj.Name = "Aniket";
obj.SayHello = (Action)(() => Console.WriteLine($"Hi {obj.Name}"));
obj.SayHello(); // Hi Aniket

Load DLLs at runtime and find all classes implementing an interface:

Assembly asm = Assembly.LoadFrom("MyPlugin.dll");
var types = asm.GetTypes().Where(t => typeof(IMyPlugin).IsAssignableFrom(t));

Uses reflection to get property names, types, and values.

• ✅ Cache Type, MethodInfo results if reused.
• ❌ Avoid overusing dynamic – leads to fragile code.
• ✅ Use reflection only when no better static alternative exists.
• ✅ Always validate dynamic method names or types before invoking.

Would you like:

• 📄 A PDF version of this for your study kit?
• 🧪 Practice exercises or quizzes?
• 🎯 Mock interview questions with sample answers?

Let me know — happy to prepare those!