All 11 Attributes & Reflection questions
More in Attributes & Reflection
How do you use reflection to read a custom attribute's values off a property at runtime? How do you dynamically create an instance of a type and invoke a method on it using reflection, when the type isn't known at compile time? What is reflection in C#, and what are its most common practical uses and performance trade-offs? How does the .NET dependency injection container and ASP.NET Core's model binding use reflection and attributes together under the hood? How do you use reflection to discover all types in an assembly that implement a specific interface, useful for plugin discovery? Why is reflection generally slower than direct code, and what techniques (like caching or compiled expressions) mitigate this cost? How would you use System.Reflection.Emit or source generators as faster, more modern alternatives to runtime reflection for code generation scenarios?
Advertisement
Back to results for “Reflection”
C# › Attributes & Reflection

How would you write a simple reflection-based object mapper that copies matching property values from one object to another of a different type?

Advanced

Answer

Iterate the source type's properties via reflection, and for each one, look up a same-named property on the destination type; if found and type-compatible, read the source value with PropertyInfo.GetValue() and write it to the destination with PropertyInfo.SetValue() — this is conceptually what libraries like AutoMapper do internally, with much more sophistication and caching for performance.
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;
}
Real-world example Building a lightweight DTO-to-entity mapper for a small project without pulling in a full mapping library dependency.

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?

Generics
All 11 Attributes & Reflection questions