Attributes & Reflection

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

[Serializable]
public class Product { public string Name { get; set; } = ""; }

Common follow-ups: Can you apply multiple attributes to the same code element?

Type type = typeof(string);
Console.WriteLine(type.Name);        // "String"
Console.WriteLine(type.Namespace);   // "System"
var methods = type.GetMethods();     // array of all public methods

Common follow-ups: What's the difference between typeof(SomeType) and instance.GetType()?

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class RequiredAttribute : Attribute {
  public string ErrorMessage { get; set; } = "This field is required.";
}

public class User {
  [Required(ErrorMessage = "Name is mandatory")]
  public string Name { get; set; } = "";
}

Common follow-ups: What does 'AllowMultiple = true' allow you to do that's normally disallowed?

var properties = typeof(User).GetProperties();
foreach (var prop in properties) {
  var required = prop.GetCustomAttribute<RequiredAttribute>();
  if (required != null) {
    Console.WriteLine($"{prop.Name}: {required.ErrorMessage}");
  }
}

Common follow-ups: How would you check whether an attribute exists WITHOUT retrieving its full instance, for a quick presence check?

Type type = Type.GetType("MyApp.Plugins.LoggerPlugin");
object instance = Activator.CreateInstance(type)!;
MethodInfo method = type.GetMethod("Log")!;
method.Invoke(instance, new object[] { "Hello from reflection!" });

Common follow-ups: What's the performance cost of Activator.CreateInstance() and MethodInfo.Invoke() compared to a direct 'new' call and method invocation?

public class UsersController : ControllerBase {
  private readonly IUserService _service; // resolved via reflection-based DI
  public UsersController(IUserService service) { _service = service; }

  [HttpPost]
  public IActionResult Create([FromBody] CreateUserRequest request) { /* ... */ }
}

Common follow-ups: Why is reflection-heavy DI/binding done ONCE at application startup rather than on every single request, for performance reasons?

public static TDest MapTo<TSource, TDest>(TSource source) where TDest : new() {
  var dest = new TDest();
  var destProps = typeof(TDest).GetProperties();
  foreach (var srcProp in typeof(TSource).GetProperties()) {
    var destProp = destProps.FirstOrDefault(p => p.Name == srcProp.Name && p.PropertyType == srcProp.PropertyType);
    destProp?.SetValue(dest, srcProp.GetValue(source));
  }
  return dest;
}

Common follow-ups: Why would a production-grade mapper like AutoMapper compile and CACHE this mapping logic instead of using raw reflection on every call?

var pluginTypes = Assembly.GetExecutingAssembly()
    .GetTypes()
    .Where(t => typeof(IPlugin).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract);

foreach (var type in pluginTypes) {
  var plugin = (IPlugin)Activator.CreateInstance(type)!;
  plugin.Execute();
}

Common follow-ups: How would you extend this to scan MULTIPLE assemblies loaded from a plugins directory at runtime?

// Slow: repeated reflection lookup every call
void SetNameSlow(object obj, string name) {
  obj.GetType().GetProperty("Name")!.SetValue(obj, name);
}

// Fast: compile once, reuse the delegate many times
var param = Expression.Parameter(typeof(User));
var prop = Expression.Property(param, "Name");
// ... build and compile an Expression<Action<User, string>> once, cache it, invoke repeatedly

Common follow-ups: At roughly what call-volume threshold does the compiled-expression approach's upfront cost start paying off over raw reflection?

// Source generator approach (conceptual): attribute triggers compile-time code generation
[JsonSerializable(typeof(User))]
partial class AppJsonContext : JsonSerializerContext { }
// The compiler generates a real, reflection-free serializer for User at BUILD time

Common follow-ups: Why does Native AOT compilation specifically struggle with (or outright disallow) certain kinds of runtime reflection?