2. Real-world story

Seller order DTOs need a fixed marketplace code (AMZ-IN), a dynamic status label built from flags, and a computed commission — fields that do not exist on the raw Order entity. AutoMapper ForMember handles all three without cluttering the controller.

3. Problem without this concept

If you ignore Fixed & Dynamic Destination Values, this is what teams struggle with:

• Duplicate logic and unclear structure
• Harder onboarding for new developers
• More bugs found only in production

4. Definition

Sometimes the destination property does not come directly from a source field. AutoMapper lets you set a fixed (constant) value — like a default currency code — or compute a dynamic value from the source object, HTTP context, or injected services.

5. Why do we need it?

API DTOs often need fields the database entity does not have: formatted labels, tenant names, audit timestamps, or flags like IsExported. Fixed and dynamic mapping avoids manual assignment in every controller action. When API DTOs differ from EF Core entities and manual mapping gets tedious.

6. Where is it used?

• API DTO mapping
• Report view models
• Integration adapters
• Map EF entities to DTOs so API responses do not leak database shape.
• Profile mapping in hot paths — manual mapping is sometimes faster.

7. How it works

• ForMember targets one destination property.
• MapFrom accepts a lambda: use s => when reading the source, _ => when the value is fixed or comes from elsewhere.
• Constants like "INR" are fixed; PriceLabel and MappedAtUtc are dynamic because they change per object or per mapping call.

8. Syntax

Core syntax pattern for Fixed & Dynamic Destination Values:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
}
public class ProductDto
{

9. Beginner example

Copy into a console project (dotnet new console → dotnet run).

// Install: dotnet add package AutoMapper.Extensions.Microsoft.DependencyInjection

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
}

public class ProductDto
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal PriceInr { get; set; }
    public string Currency { get; set; } = "";
    public string PriceLabel { get; set; } = "";
    public DateTime MappedAtUtc { get; set; }
}

public class ProductProfile : Profile
{
    public ProductProfile()
    {
        CreateMap<Product, ProductDto>()
            // Fixed value — same for every mapped row
            .ForMember(d => d.Currency, opt => opt.MapFrom(_ => "INR"))
            // Dynamic value — computed from source
            .ForMember(d => d.PriceInr, opt => opt.MapFrom(s => s.Price))
            .ForMember(d => d.PriceLabel, opt => opt.MapFrom(s => $"₹{s.Price:N2}"))
            // Dynamic value — not from source at all (runtime clock)
            .ForMember(d => d.MappedAtUtc, opt => opt.MapFrom(_ => DateTime.UtcNow));
    }
}

Line-by-line

10. Real project example

Seller order DTOs need a fixed marketplace code (AMZ-IN), a dynamic status label built from flags, and a computed commission — fields that do not exist on the raw Order entity. AutoMapper ForMember handles all three without cluttering the controller.

Production-style C#

public class Order { public int Id { get; set; } public decimal Amount { get; set; } public bool IsFulfilled { get; set; } }
public class OrderDto { public int Id { get; set; } public string Marketplace { get; set; } = ""; public string StatusLabel { get; set; } = ""; public decimal Commission { get; set; } }

CreateMap<Order, OrderDto>()
    .ForMember(d => d.Marketplace, o => o.MapFrom(_ => "AMZ-IN"))
    .ForMember(d => d.StatusLabel, o => o.MapFrom(s => s.IsFulfilled ? "Delivered" : "Processing"))
    .ForMember(d => d.Commission, o => o.MapFrom(s => s.Amount * 0.12m));

Why teams use this: Product teams add new DTO display fields in one Profile instead of touching every API endpoint.

11. Visual understanding

Input (user, file, API)
        │
        ▼
   Fixed & Dynamic Destination Values logic in C#
        │
        ▼
   Output (console, HTTP response, file)

12. Internal working

• Roslyn compiler checks syntax and types before your program runs.
• CLR executes IL and provides services (GC, exceptions, threading).
• For this lesson, focus on behavior first — runtime details matter more as apps grow.

13. Advantages

• Readable code that new team members can follow
• Compiler catches many mistakes before deploy
• Huge .NET job market in India and worldwide

14. Disadvantages

• Takes time to learn if you skip fundamentals
• Overusing advanced features too early adds complexity

15. Best practices

• Use meaningful names — `transferAmount` not `x`
• Run `dotnet format` or EditorConfig for consistent style
• Commit small examples to Git from lesson one

16. Common mistakes

• Hard-coding MapFrom(_ => DateTime.UtcNow) when you need the database CreatedAt — map from source instead.
• Forgetting that MapFrom runs per mapping — expensive I/O inside lambdas hurts performance.
• Using fixed values for fields that should vary by tenant or user — inject a resolver instead.

17. Interview questions

Do this on your computer

1. Define source entity and destination DTO with extra properties
2. In Profile, chain ForMember for each non-trivial destination field
3. Use MapFrom(_ => constant) for fixed values
4. Use MapFrom(s => expression) for values derived from source
5. Call mapper.Map(product) and verify Currency and PriceLabel
6. Read the real-world section and identify which layer (API, service, domain) uses this topic.
7. Run dotnet build and dotnet run locally — confirm output.
8. Change one value and predict the result before saving.

Experiments — try changing this

• Change a number or string in the example and run again — predict output first.
• Introduce a deliberate error (remove a semicolon) and read the compiler message.
• Add one more item to the collection and confirm the loop runs one extra time.
• Open dotnet docs for Fixed & Dynamic Destination Values and compare one keyword with the lesson example.

18. Summary

• Fixed values: MapFrom(_ => "constant").
• Dynamic from source: MapFrom(s => transform(s.Field)).
• Runtime/di values: IValueResolver or AfterMap.
• Keeps controllers thin — mapping rules live in Profile.