LiteMapper 1.0.0

LiteMapper

A lightweight, zero-dependency object mapping library for .NET 8 that maps between DTOs, ViewModels, and Entities automatically.

Features

• Zero Dependencies: No external dependencies
• Convention-Based Mapping: Automatically maps properties with matching names (case-insensitive)
• Custom Property Mapping: Fluent API for custom transformations
• Collection Mapping: Built-in support for mapping collections
• Type Conversion: Automatic type conversion for compatible types
• Property Ignoring: Exclude specific properties from mapping
• Thread-Safe: Uses concurrent dictionaries for caching
• Performance: Caches reflection metadata for fast repeated mappings

Installation

dotnet add package LiteMapper

Quick Start

using LiteMapper;

// Create mapper instance
var mapper = new Mapper();

// Simple convention-based mapping
var userDto = mapper.Map<UserEntity, UserDto>(userEntity);

// Custom mapping configuration
mapper.CreateMap<UserEntity, UserDto>()
    .ForMember(dest => dest.FullName, src => $"{src.FirstName} {src.LastName}")
    .ForMember(dest => dest.Status, src => src.IsActive ? "Active" : "Inactive")
    .Ignore(dest => dest.Email);

// Map collections
var userDtos = mapper.Map<UserEntity, UserDto>(userEntities);

Usage Examples

Convention-Based Mapping

Properties with matching names are automatically mapped:

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 Price { get; set; }
}

var mapper = new Mapper();
var productDto = mapper.Map<Product, ProductDto>(product);

Custom Property Mapping

Use ForMember to define custom mappings:

mapper.CreateMap<Product, ProductViewModel>()
    .ForMember(dest => dest.PriceFormatted, src => $"${src.Price:F2}")
    .ForMember(dest => dest.InStock, src => src.Stock > 0);

Ignoring Properties

Exclude properties from mapping:

mapper.CreateMap<User, UserDto>()
    .Ignore(dest => dest.PasswordHash);

Collection Mapping

Map collections of objects:

IEnumerable<Product> products = GetProducts();
var productDtos = mapper.Map<Product, ProductDto>(products);

Mapping to Existing Instance

Update an existing object:

var existingDto = new UserDto();
mapper.Map(userEntity, existingDto);

Performance Considerations

• Property mappings are cached after first use
• Reflection overhead is minimized through caching
• Thread-safe implementation using ConcurrentDictionary
• No runtime IL generation or compilation

Type Conversion

LiteMapper automatically handles:

• Primitive type conversions
• Nullable types
• Enum conversions
• String to enum parsing

License

MIT License

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.