riok/mapperly

Features

• Source Generators - Uses C# source generators to produce mapping code during compilation, eliminating runtime reflection.
• .NET Object Mapping - Provides high-performance object mapping for the .NET ecosystem using source generators to avoid reflection.
• Data Projections - Maps data from queryable sources to target types to optimize database performance.
• Query Projections - Translates mapping definitions into database-level query projections to optimize data retrieval.
• API-to-Domain Mapping - Automates the conversion between internal domain models and data transfer objects for API and database layers.
• Object-to-Object Mappers - Generates code to transfer data between different .NET object types without manual assignment logic.
• C# Source Code Generators - Uses C# source generators to automate the production of mapping code during the build process.
• Compile-Time Field Mapping - Resolves object property assignments at compile time to maximize execution performance by avoiding reflection.
• Object Type Transformations - Provides automated code generation for transferring data between different .NET object types, interfaces, and generics.
• Property Strictness - Triggers diagnostic warnings or errors when source or target members remain unmapped to ensure schema integrity.
• Automatic Object Mappers - Generates conversion logic using direct assignments, casts, and constructors.
• Compile-Time Mapping Validations - Analyzes mapping signatures at compile time to emit warnings for unmapped properties.
• Data Transfer Object Mapping - Automates the conversion of data between internal domain models and data transfer objects.
• Strict Mapping Enforcement - Verifies that every source member is mapped to a target member and reports gaps as compile-time warnings.
• Property Name Heuristics - Automatically matches source and target properties using naming conventions and case-insensitive analysis.
• Collection Element Mapping - Maps members and constructor parameters within a loop when converting collections of objects.
• Complex Data Structure Transformation - Performs complex transformations by flattening nested hierarchies or expanding flat structures.
• Mapping Validation - Analyzes mapping signatures and member availability at compile time to prevent invalid configurations.
• Custom Enum Value Assignments - Translates values between enums, strings, and primitive types using custom naming or explicit value strategies.
• Enum Fallback Management - Provides fallback mechanisms to handle unknown enum values by redirecting them to specified defaults.
• Nested Attribute Flattening - Converts nested object structures into flat target properties using naming conventions.
• Null Value Handling - Defines strategies for handling null source values, including assigning them, ignoring them, or throwing exceptions.
• Object Flattening - Transforms nested object hierarchies into single-level structures or expands flat properties into nested objects.
• Expression Tree Translation - Translates mapping definitions into expression trees to optimize database retrieval by fetching only required fields.
• Deep Class Instance Cloning - Creates full independent copies of nested objects and collections to isolate data.
• Static Mapping Method Generation - Generates mapping logic as static methods to support interface implementations and simplify method resolution.
• Transformation Method Generation - Produces static methods for object transformations to ensure high performance and simplified discovery.
• Automated Constructor Analysis - Automates object instantiation by analyzing target constructors and their parameters.
• Enum Type Conversions - Translates values between enums and strings or different enum types by name or value.
• Explicit Member Mapping - Manually links specific source enum values to specific target values by overriding automatic discovery.
• Generic Types - Generates mapping logic for methods with type parameters that satisfy source and target constraints.
• Collection Format Conversions - Provides conversion between various collection types including Enumerable, Dictionary, Span, Memory, and Queryable.
• Constructor Parameter Mapping - Links specific source properties to target constructor parameters when names do not match.
• Constructor Selection Logic - Invokes the most appropriate target constructor based on parameter count or signature preference.
• Member Matching Strategies - Matches enum entries based on underlying values or exact names with case-insensitive options.
• Object Initializers - Creates target instances using constructors, custom factories, or by updating existing objects.
• Enum-to-String Converters - Converts enum values to strings using customizable naming strategies like camelCase or snake_case.
• Property Exclusion - Prevents specific class properties from being mapped using ignore annotations.
• Custom Mapping Logic Integration - Supports the integration of custom user-defined methods to handle complex data transformations.
• Circular Reference Detection - Tracks and reuses object instances during mapping to prevent infinite loops in self-referencing structures.
• Reference Tracking - Maintains a registry of mapped objects to prevent infinite loops and preserve identity during deep cloning.
• Mapping Completeness Validations - Validates that all required properties are mapped and flags missing entries during the generation process.
• In-Place Object Updating - Updates a provided target object instance with source values instead of creating a new instance.
• Object Property Customizations - Provides capabilities to rename members or ignore specific fields during the object mapping process.
• Nested Property Extractors - Matches nested source properties to flat target properties by analyzing member name permutations.
• Property Matching Strategies - Provides configurable property matching, such as case-insensitive name matching, to align source and target members.
• Strict Enum Mapping Validations - Provides compile-time diagnostics to ensure all enum members are mapped, preventing runtime missing-mapping errors.
• Core .NET Libraries - Source generator-based mapper for compile-time type-safe transformations.
• Object Mapping - Source generator for high-performance object mapping without runtime reflection.

Istoric stele