使用AutoMapper为何需调用CreateMap()？无配置仍可用的原因解析

Great question—let’s break this down clearly, since AutoMapper’s behavior here can feel counterintuitive at first!

At its core, CreateMap<TSource, TDestination>() is how you explicitly define and validate the mapping relationship between two types. AutoMapper isn’t a "magic" tool that guesses your intentions perfectly—this method does three critical things:

• Establishes a clear contract: It tells AutoMapper "we intend to map instances of TSource to TDestination", letting the library precompute and cache mapping logic upfront (instead of figuring it out on the fly every time).
• Unlocks custom configuration: The default name-matching behavior only gets you so far. CreateMap() is the entry point for adding tailored rules like:
  • Combining properties: CreateMap<User, UserDto>().ForMember(dest => dest.FullName, opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"))
  • Sensitive field exclusion: CreateMap<User, UserDto>().ForMember(dest => dest.PasswordHash, opt => opt.Ignore())
  • Conditional mappings: CreateMap<Order, OrderDto>().ForMember(dest => dest.IsShipped, opt => opt.MapFrom(src => src.ShipDate != null))
• Catches errors early: After defining maps, you can run mapperConfiguration.AssertConfigurationIsValid() to spot missing mappings or type mismatches at app startup, instead of waiting for a runtime crash.

Without CreateMap(), any working mapping relies on AutoMapper’s fallback inline mapping behavior—not its intended, supported workflow.

While inline mapping (mapping types without predefining CreateMap()) might work for quick tests, it’s not recommended for production code—here’s why:

• Worse performance: Inline mapping forces AutoMapper to dynamically generate mapping logic via reflection every time you call Map(). Predefining CreateMap() caches this logic once at startup, which is far faster for repeated use.
• Hidden bugs: Inline mapping skips upfront validation. If you rename a property in TSource but forget to update TDestination, you won’t notice until the code runs and that property is unexpectedly null. With CreateMap() and validation, you catch this error immediately when your app launches.
• Limited functionality: Inline mapping only uses AutoMapper’s default rules. You can’t add custom property mappings, use value resolvers, or apply conditional logic—all common needs in real-world apps.
• Poor maintainability: Explicit CreateMap() calls act as living documentation. Anyone reading your code can quickly see which types are mapped and what rules apply. Inline mappings are scattered throughout your codebase, making them hard to track and update.
• Legacy status: AutoMapper’s development team has explicitly labeled inline mapping as a legacy feature. Newer versions disable it by default, requiring manual opt-in—and even then, it’s not encouraged for long-term use.

In short: Inline mapping is a convenience for prototypes, but explicit CreateMap() configurations are the only reliable, maintainable way to use AutoMapper in production.

内容的提问来源于stack exchange，提问作者Morteza