updated reflection benchmarks

Author: sj-net

docs/Posts/c# cost of reflection.md

@@ -74,15 +74,17 @@ When I did the benchmarks for setting a value using reflection, I saw using an i
 
 As this worked out very well, and I had too many model's so I built our own source generator using a console app as I was using .NET6 where the source generators are still experimental. And this whole implementation brought down our app launch time from 60+ seconds to less than 20 seconds. Btw, the properties inside the Model used to change very rarely. So when they did, we used to run the generator again and copy the files. And we ensure these generated files should never be changed manually and named them something like Foo.g.cs which helps me review the PR's easily from the team. And ofcourse, I wrote an API to return the properties and their metadata in the way that I need so that my generator can generate the classes for me. 
 
+## Version 2: (Update on  16th March 2025)
+Uses `ReadOnlySpan<char>` but same like V3.
 
-## Version 2: (Update on  16th March 2025) 
+## Version 3: (Update on  22th March 2025) 
 
 I read in multiple blogs that .NET invested a lot in performance improvement using ReadOnlySpan over the years. I was wondering if we can still make this better. So I tried again with ChatGPT help. Now compared to V1, V2 had at least 40% improvement over V1. 
 
 I renamed the interface like 
 
 ```csharp
- public interface INoReflection
+ public interface IObject
  {
     bool SetValue(string propertyName, object value);
     object GetValue(string propertyName);
@@ -93,7 +95,7 @@ I renamed the interface like
 Nothing changed in my interface. But the implementation changed a bit.
 
 ```csharp
-[TypedAccessorAttribute]
+[DynamicIObject]
 public partial class Foo
 {
     public int Integer { get; set; } = int.MaxValue;
@@ -102,7 +104,7 @@ public partial class Foo
 }
 ```
 
-Notice the `TypedAccessorAttribute` on top of class. And yes this time I used Incremental Source Generators as they are stable.
+Notice the `DynamicIObject` on top of class. And yes this time I used Incremental Source Generators as they are stable.
 
 And my implementation is like 
 
@@ -111,48 +113,49 @@ And my implementation is like
 [MethodImpl(MethodImplOptions.AggressiveInlining)]
 public bool SetValue(string propertyName, object value)
 {
-    ReadOnlySpan<char> span = propertyName;
-    switch (span.Length)
+    switch (propertyName.Length)
     {
-        case 7 when span.SequenceEqual("Integer"):
-            Integer = (int)value;
-            return true;
-        case 6 when span.SequenceEqual("String"):
+        case 6 when string.CompareOrdinal(propertyName, "String") == 0:
             String = (string)value;
             return true;
+        case 7 when string.CompareOrdinal(propertyName, "Integer") == 0:
+            Integer = (int)value;
+            return true;
     }
     return false;
 }
 
 [MethodImpl(MethodImplOptions.AggressiveInlining)]
 public object GetValue(string propertyName)
 {
-    ReadOnlySpan<char> span = propertyName;
-    switch (span.Length)
+    return propertyName.Length switch
     {
-        case 7 when span.SequenceEqual("Integer"):
-            return Integer;
-        case 6 when span.SequenceEqual("String"):
-            return String;
-    }
-    return null;
+        6 when string.CompareOrdinal(propertyName, "String") == 0 => String,
+        7 when string.CompareOrdinal(propertyName, "Integer") == 0 => Integer,
+        _ => Unsafe.NullRef<object>(),
+    };
 }
 
 ```
 
-As I said, I took ChatGPT help, I am not 100% sure how `MethodImpl` helps. But this code brought down time taken to set a property from V1 to a min of 40% and max of 55%. 
+As I said, I took ChatGPT help, I am not 100% sure how `MethodImpl` helps.
+
+### Here are the benchmarks
 
-### Here are the V2 Benchmarks: 
+1. Reflection_Without_Cache
+2. Reflection_With_Cache
+3. V1 - use `nameof(Integer)` inside switch 
+4. V2 - use `case 8 when span.SequenceEqual("DateTime")` inside switch
+5. V3 - use ` case 4 when string.CompareOrdinal(propertyName, "Guid") == 0` inside switch
 
-.NET 8 only.
-{% include_relative reflection-benchmarks-v2-net8.md %}
+For some scenarios, V1 and V2 are better than V3. But ultimately V1, V2, V3 are found to be much faster than reflection. 
 
-.NET6, .NET7, .NET8, .NET9
-{% include_relative reflection-benchmarks-v2-net6-net7-net8-net9.md %}
 
-[V2 Source Code](https://github.com/DotNetExtended/Default/tree/main/src/DotNetExtended.NoReflection)
-[V2 Benchmarks Source Code](https://github.com/DotNetExtended/Default/tree/main/src/DotNetExtended.NoReflection.Tests)
-[V2 Source Generator](https://github.com/DotNetExtended/Default/tree/main/src/DotNetExtended.NoReflection.SourceGenerators)
+.NET 8 only.   
+{% include_relative reflection-benchmarks-v1-v2-v3-net8.md %}
+[Source Code](https://github.com/DotNetExtended/Default/tree/main/src/DotNetExtended.NoReflection)
+[Benchmarks Source Code](https://github.com/DotNetExtended/Default/tree/main/src/DotNetExtended.NoReflection.Tests)
+[Source Generator](https://github.com/DotNetExtended/Default/tree/main/src/DotNetExtended.NoReflection.SourceGenerators)
 
 
 This is one of my best performance improvements I have ever done. This might not be significant in many places  but for situations like mine, this saves a lot of time during run time.