Hypercubus.Mapping 0.6.0

Hypercubus Mapper

A fast and minimalist object to object mapper for .Net.
 

Usage

All the configured mapping is managed by the Hypercubus.Mapping.Mapper class. You can use it with your favorite dependency injection framework to inject the mapper instance in your Asp.Net controller classes.
 

Configuration

services.AddSingleton(sc =>
{
    var mapper = new Hypercubus.Mapping.Mapper();

    mapper.Configure<Phone, PhoneDto>((m, s) => new PhoneDto()
    {
        Id = s.Id,
        Number = s.Number
    });

    mapper.Configure<User, UserDto>((m, s) => new UserDto()
    {
        Id = s.Id,
        UserName = s.UserName
    });

    mapper.Configure<Person, PersonDto>((m, s) => new PersonDto()
    {
        Id = s.Id,
        Name = s.Name,
        Age = s.Age,
        UserLog = m.Map(s.UserLog).To<UserDto>(), // New Syntax!
        Phones = m.Map<List<Phone>, PhoneDto[]>(s.Phones)
    });

    return mapper;
});

IEnumerable, Array, and List configurations are automatically added to your configured types by default. You can disable this for a individual Type by using the overload of the Configure method that has a addDefaultEnumerableTypes parameter.
 

Mapper Usage

After injecting it in your controllers just make a simple call like this:

List<PersonDto> personsDto = mapper.Map(persons).To<List<PersonDto>>();

If you use a single set of mapping rules, i.e. a single Mapper class, you can use a shorter and easier to write mapping extension method:

List<PersonDto> personsDto = persons.Map().To<List<PersonDto>>();

This will be based on the default Mapper which is the first Mapper created in the current process and can also be changed when needed:

Mapper.ChangeDefault(alternateMapper);

Why use this library?

WYSIWYG and No Complex Configurations

Keep it Simple, Silly 😉
 

Validate your Mappings Rules at Compile Time

Fully automated mapping might seem useful, but it can become a problem when properties are changed or renamed and things stop working and the team doesn't immediately know why. Hypercubus.Mapping always enforces the use of explicit mappings that avoid this kind of situation.  

Similar or even Faster than Traditional Handwritten Code

Why write mappings code by hand every time when you can make this process standard and reuse mapping rules by adopting a mapper library? And with a big plus that makes your code run FASTER.

With very simple POCO classes, Hypercubus Mapper runs typically in a time equivalent to handwriting and rarely adds a maximum of 9% time overhead. Still, when classes become more complex - with other classes referenced - it can save up to 46% mapping processing time.
 

Pure .NET Standard 2.0 Code with No Dependencies

This library does not use Reflection.Emit package so it can be used in Xamarin, Mono, and UWP projects without a problem.
 

Allows Multiple Profiles

To add multiple profiles just create another Mapper instance and configure its mappings.
 

Performance and Memory efficiency

Great performance and low memory footprint using lightweight c# features like delegates and structs plus some nice caching techniques.