CompactMapper 1.0.1

<div align="center"> <img src="logo.png" alt="CompactMapper Logo" width="200"> </div>

📦 CompactMapper

CompactMapper is a lightweight, fast, and fully open-source object mapper for .NET that lets you map objects between types — including complex types and collections — with just one line of code.

🟢 No dependencies. No profiles. No configuration. Just pure mapping.
🔄 An open-source alternative to AutoMapper, which is now commercially licensed.

Created by Hoskes

🚀 Why CompactMapper?

AutoMapper is an industry-standard library for object mapping in .NET — but starting from version 12, AutoMapper is no longer free for commercial use under its new license.

CompactMapper is:

• ✅ Free and open-source
• ✅ Simple and extensible
• ✅ Handles nested mapping and collections
• ✅ Ideal for DTO mapping, clean architecture, and layering concerns

✨ Features

• 🔄 Automatic mapping of properties by name (case-insensitive)
• 🧠 Recursive mapping of nested objects
• 📚 Collection and array mapping
• 🎯 Optional custom mappings using lambdas
• 🧰 Optional value transformers (e.g., trimming, formatting, sanitizing)
• 💡 No reflection after initial setup — highly efficient

📦 Installation

Option 1: NuGet Package (Recommended)

# Using Package Manager Console
Install-Package CompactMapper

# Using .NET CLI
dotnet add package CompactMapper

# Using PackageReference in .csproj file
<PackageReference Include="CompactMapper" Version="1.0.1" />

After installing, add the namespace in your code files:

using CompactMapper;

Option 2: Manual Installation

Copy the CompactMapperExtension class into your project.

🧑‍💻 Usage

🔹 1. Basic Mapping

var customerDto = customer.MapTo<CustomerDto>();

🔹 2. Mapping with Nested Objects

var dto = order.MapTo<OrderDto>(); // Will also map order.Customer, order.Items, etc.

🔹 3. Mapping Collections

List<CustomerDto> customerDtos = customers.MapTo<List<CustomerDto>>();

Works for List<T>, IEnumerable<T>, T[], etc.

🔹 4. Custom Mapping Logic

CompactMapperExtension.AddCustomMapping<Customer, CustomerDto>((src, dest) =>
{
    dest.FullName = $"{src.FirstName} {src.LastName}";
});

🔹 5. Value Transformation (Optional)

var dto = user.MapTo<UserDto>(valueTransformer: (prop, value) =>
{
    if (prop == "Email" && value is string email)
        return email.ToLowerInvariant();

    return value;
});

📐 Example

🧱 Entities

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Address Address { get; set; }
    public List<Order> Orders { get; set; }
}

public class Address
{
    public string Street { get; set; }
}

📦 DTOs

public class CustomerDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public AddressDto Address { get; set; }
    public List<OrderDto> Orders { get; set; }
}

public class AddressDto
{
    public string Street { get; set; }
}

✅ Mapping

var customerDto = customer.MapTo<CustomerDto>();

No config, no fuss — deeply nested and collections mapped out of the box!

💬 Why Not AutoMapper?

🛠️ Under the Hood

• Uses reflection only at runtime, no compilation step
• Recursive mapping using MethodInfo.MakeGenericMethod
• Collection type detection via IEnumerable<> interfaces
• Internal registry of custom mappings per type pair

📣 Roadmap

• NuGet Package: CompactMapper
• Fluent API style (optional config)
• Support for flattening/nested property paths
• Dictionary mapping (Dictionary<string, object> ↔ POCO)

📝 License

MIT License – free to use for personal and commercial projects.

🙌 Contributing

Want to help improve CompactMapper? PRs are welcome!
If you'd like to add features or extensions (like flattening or reverse mapping), feel free to fork and contribute.

📫 Contact

Feel free to open an issue or reach out if you use CompactMapper in your project — we'd love to hear how it's helping!