Merge pull request #166 from DanielTrommel/advanced-property-path

Support for more advanced path definitions

Author: w-ahmad

src/Extensions/ObjectExtensions.cs

@@ -1,13 +1,19 @@
 using System;
+using System.Collections;
 using System.Reflection;
+using System.Text.RegularExpressions;
 
 namespace WinUI.TableView.Extensions;
 
 /// <summary>
 /// Provides extension methods for object types.
 /// </summary>
-internal static class ObjectExtensions
+internal static partial class ObjectExtensions
 {
+    // Regex to split property paths into property names and indexers (for cases like e.g. "[2].Foo[0].Bar", where Foo might be a Property that returns an array)
+    [GeneratedRegex(@"([^.[]+)|(\[[^\]]+\])", RegexOptions.Compiled)]
+    private static partial Regex PropertyPathRegex();
+
     /// <summary>
     /// Gets the value of a property from an object using a sequence of property info and index pairs.
     /// </summary>
@@ -16,14 +22,39 @@ internal static class ObjectExtensions
     /// <returns>The value of the property, or null if the object is null.</returns>
     internal static object? GetValue(this object? obj, (PropertyInfo pi, object? index)[] pis)
     {
-        foreach (var pi in pis)
+        foreach (var (pi, index) in pis)
         {
             if (obj is null)
-            {
                 break;
-            }
 
-            obj = pi.index is not null ? pi.pi.GetValue(obj, [pi.index]) : pi.pi.GetValue(obj);
+            if (pi != null)
+            {
+                // Use property getter, with or without index
+                obj = index is not null ? pi.GetValue(obj, [index]) : pi.GetValue(obj);
+            }
+            else if (index is int i)
+            {
+                // Array
+                if (obj is Array arr)
+                {
+                    obj = arr.GetValue(i);
+                }
+                // IList
+                else if (obj is IList list)
+                {
+                    obj = list[i];
+                }
+                else
+                {
+                    // Not a supported indexer type
+                    return null;
+                }
+            }
+            else
+            {
+                // Not a supported path segment
+                return null;
+            }
         }
 
         return obj;
@@ -39,41 +70,88 @@ internal static class ObjectExtensions
     /// <returns>The value of the property, or null if the object is null.</returns>
     internal static object? GetValue(this object? obj, Type? type, string? path, out (PropertyInfo pi, object? index)[] pis)
     {
-        var parts = path?.Split('.');
+        if (obj == null || string.IsNullOrWhiteSpace(path) || type == null)
+        {
+            pis = [];
+            return obj;
+        }
 
-        if (parts is null)
+        var matches = PropertyPathRegex().Matches(path);
+        if (matches.Count == 0)
         {
             pis = [];
             return obj;
         }
 
-        pis = new (PropertyInfo, object?)[parts.Length];
+        // Pre-size the steps array to the number of matches
+        pis = new (PropertyInfo, object?)[matches.Count];
+        int i = 0;
+        object? current = obj;
+        Type? currentType = type;
 
-        for (var i = 0; i < parts.Length; i++)
+        foreach (Match match in matches)
         {
-            var part = parts[i];
-            var index = default(object?);
+            string part = match.Value;
+            object? index = null;
+            PropertyInfo? pi = null;
+
             if (part.StartsWith('[') && part.EndsWith(']'))
             {
-                index = int.TryParse(part[1..^1], out var ind) ? ind : index;
-                part = "Item";
-            }
+                // Indexer: [index] or [key]
+                string indexer = part[1..^1];
+                if (int.TryParse(indexer, out int intIndex))
+                    index = intIndex;
+                else
+                    index = indexer;
 
-            var pi = type?.GetProperty(part);
-            if (pi is not null)
-            {
-                pis[i] = (pi, index);
-                obj = index is not null ? pi?.GetValue(obj, [index]) : pi?.GetValue(obj);
-                type = obj?.GetType();
+                // Try array
+                if (current is Array arr && index is int idx)
+                {
+                    current = arr.GetValue(idx);
+                    pis[i++] = (null!, idx);
+                    currentType = current?.GetType();
+                    continue;
+                }
+
+                // Try IList
+                if (current is IList list && index is int idx2)
+                {
+                    current = list[idx2];
+                    pis[i++] = (null!, idx2);
+                    currentType = current?.GetType();
+                    continue;
+                }
+
+                // Try default indexer property (e.g., this[string])
+                pi = currentType?.GetProperty("Item");
+                if (pi != null)
+                {
+                    current = pi.GetValue(current, [index]);
+                    pis[i++] = (pi, index);
+                    currentType = current?.GetType();
+                    continue;
+                }
+
+                // Not found
+                pis = null!;
+                return null;
             }
             else
             {
-                pis = null!;
-                return null;
+                // Property access
+                pi = currentType?.GetProperty(part, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                if (pi == null)
+                {
+                    pis = null!;
+                    return null;
+                }
+                current = pi.GetValue(current);
+                pis[i++] = (pi, null);
+                currentType = current?.GetType();
             }
         }
 
-        return obj;
+        return current;
     }
 
     /// <summary>