Update README.md

Author: jeevasusej

README.md

@@ -1,140 +1,183 @@
 # ValueMapper
 
-ValueMapper is a straightforward, easy-to-use object-to-object mapping utility for .NET. It provides a convenient way to map properties between different object types with minimal configuration.
+A high-performance, lightweight object-to-object mapper for .NET with zero dependencies. ValueMapper provides fast mapping capabilities with a simple API, making it easy to map between different object types while maintaining good performance.
+
+## Features
+
+- ✨ Zero dependencies
+- 🚀 High performance
+- 💡 Simple API
+- 🔄 Automatic type conversion
+- 🏷️ Custom property mapping via attributes
+- ⏭️ Property ignoring
+- 📝 Collection mapping
+- 🔄 Enum mapping (case-insensitive)
+- 🧵 Parallel collection mapping for large datasets
+- 🔒 Thread-safe operation
+- 🔥 Mapping compilation caching
 
 ## Installation
 
 ```shell
 dotnet add package ValueMapper
 ```
 
-## Quick Start
+## Usage Examples
+
+### Basic Property Mapping
 
 ```csharp
-using ValueMapperUtility;
+var source = new Source
+{
+    Name = "John Doe",
+    Age = 30,
+    City = "New York"
+};
+
+var destination = ValueMapper.Map<Source, Destination>(source);
+```
 
-// Define your classes
-public class UserDto
+### Custom Property Mapping Using Attributes
+
+```csharp
+public class Source
 {
-    public string Name { get; set; }
-    public int Age { get; set; }
+    [ValueMapperMapping("CustomName")]
+    public string SourceProperty { get; set; }
 }
 
-public class UserEntity
+public class Destination
 {
-    public string Name { get; set; }
-    public int Age { get; set; }
+    public string CustomName { get; set; }
 }
 
-// Perform mapping
-var dto = new UserDto { Name = "John Doe", Age = 30 };
-var entity = ValueMapper.Map<UserDto, UserEntity>(dto);
+var source = new Source { SourceProperty = "Custom Value" };
+var destination = ValueMapper.Map<Source, Destination>(source);
+// destination.CustomName will contain "Custom Value"
 ```
 
-## Features
-
-- Simple property matching by name
-- Basic type conversion support
-- Custom property mapping using attributes
-- Property exclusion support
-- Collection mapping
-- Enum mapping support
+### Ignoring Properties
 
-## Documentation
+```csharp
+public class Source
+{
+    public string Name { get; set; }
+    [ValueMapperIgnore]
+    public string IgnoredProperty { get; set; }
+}
 
-For full documentation, visit our [GitHub repository](https://github.com/TechFusionMasters/ValueMapper).
+// Or ignore properties at runtime
+var ignoredProperties = new HashSet<string> { "Age" };
+var destination = ValueMapper.Map<Source, Destination>(source, ignoredProperties);
+```
 
 ### Collection Mapping
 
-ValueMapper provides support for collections in two ways:
-
-1. Mapping Lists of Objects using `MapList`:
-
 ```csharp
-var dtoList = new List<UserDto>
+var sourceList = new List<Source>
 {
-    new UserDto { Name = "John Doe", Age = 30 },
-    new UserDto { Name = "Jane Doe", Age = 28 }
+    new Source { Name = "John", Age = 30 },
+    new Source { Name = "Jane", Age = 25 }
 };
 
-// Maps each object in the list, with automatic parallelization for large lists
-var entityList = ValueMapper.MapList<UserDto, UserEntity>(dtoList);
+var destinationList = ValueMapper.MapList<Source, Destination>(sourceList);
 ```
 
-2. Mapping Collection Properties:
+### Enum Mapping (Case-Insensitive)
 
 ```csharp
-public class UserDto
+public enum SampleEnum
 {
-    public string Name { get; set; }
-    public List<string> Roles { get; set; }
+    None,
+    Value1,
+    Value2
 }
 
-public class UserEntity
+public class Source
 {
-    public string Name { get; set; }
-    public List<string> Roles { get; set; }
+    public string EnumValue { get; set; }  // Can be "Value1" or "value1"
 }
 
-// Both Name and Roles will be mapped automatically
-var dto = new UserDto
+public class Destination
 {
-    Name = "John",
-    Roles = new List<string> { "Admin", "User" }
-};
-
-var entity = ValueMapper.Map<UserDto, UserEntity>(dto);
+    public SampleEnum EnumValue { get; set; }
+}
 ```
 
-### Custom Property Mapping
-
-Use the `ValueMapperMappingAttribute` to map properties with different names:
+### Type Conversion Support
 
 ```csharp
 public class Source
 {
-    public string FullName { get; set; }
+    public int IntValue { get; set; }
+    public double DoubleValue { get; set; }
+    public string StringNumber { get; set; }
 }
 
 public class Destination
 {
-    [ValueMapperMapping("FullName")]
-    public string Name { get; set; }
+    public long LongValue { get; set; }      // Converts from int
+    public float FloatValue { get; set; }    // Converts from double
+    public int IntFromString { get; set; }   // Converts from string
 }
 ```
 
-### Ignoring Properties
-
-Use the `ValueMapperIgnoreAttribute` to exclude properties from mapping:
+### Nullable Handling
 
 ```csharp
-public class UserEntity
+public class Source
 {
-    public string Name { get; set; }
+    public string Value { get; set; }  // Can be null
+}
 
-    [ValueMapperIgnore]
-    public string InternalId { get; set; }
+public class Destination
+{
+    public int? NullableValue { get; set; }  // Will be null if source is null
 }
 ```
 
-### Type Conversion Support
+## Performance
+
+ValueMapper is designed for high performance. Here are some benchmark results comparing it with other popular mappers:
+
+- Single object mapping
+- Collection mapping (100,000 items)
+- Parallel collection mapping
+- Cold start vs. Cached performance
+
+Run the benchmarks yourself:
+
+```shell
+cd ValueMapper/Benchmark
+dotnet run         # Full benchmarks
+dotnet run quick   # Quick benchmarks
+```
+
+## Cache Management
+
+```csharp
+// Clear all caches
+ValueMapper.ClearCaches();
+
+// Pre-warm mapping for specific types
+ValueMapper.PreWarmMapping<Source, Destination>();
+
+// Clear cache for specific types
+ValueMapper.Clear<Source, Destination>();
+```
 
-ValueMapper handles various type conversions:
+## Known Limitations
 
-- Numeric type conversions (int, long, double, decimal, etc.)
-- String to/from numeric types
-- String to/from enum types (with case-insensitive parsing)
-- Enum to/from numeric types
-- Nullable type handling
-- Custom type conversions through the Convert.ChangeType method
+1. Deep object mapping is not currently supported
 
-## Limitations
+   - The `Map_DeepObjectMapping_ShouldMapCorrectly` test demonstrates this limitation
+   - Complex nested objects with multiple levels are not automatically mapped
 
-- Does not support deep object mapping (nested objects must be mapped separately)
-- Only public properties are mapped
-- Properties must have both getter and setter to be mapped
-- Basic caching implementation
-- Not optimized for high-performance scenarios
+2. No circular reference detection
+3. No support for mapping private properties
+4. Collection type conversion (e.g., List<T> to Array<T>) is not supported
+5. No support for custom value converters
+6. No support for conditional mapping
 
 ## Contributing