Recursing private fields (improved), C#

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Microsoft (R) Visual C# Compiler version 2.9.0.63208 (958f2354)

using System;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] s)
        {
            var a1 =  new A(new B(new C[] { new C(1), new C(2), new C(3) }));
            Console.WriteLine(GetFieldValueByPath(a1, "b.cItems[2].target"));
            
            var a2 =  new A(new B(new C[] { } ));
            Console.WriteLine(GetFieldValueByPath(a2, "b.cItems[2].target"));
            
            var a3 =  new A(new B(null));
            Console.WriteLine(GetFieldValueByPath(a3, "b.cItems[2].target"));
        }
        public static object GetFieldValueByPath(object obj, string fieldPath)
        {
            var flags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            var parts = Regex.Matches(fieldPath, @"([^.\[]+)(?:\[(.*?)\])?").Cast<Match>().Select(match => match.Groups).ToList();
            return GetFieldValueByPathParts(obj, parts, flags);
        }
        private static object GetFieldValueByPathParts(object obj, List<GroupCollection> parts, BindingFlags flags)
        {
            if (obj == null || parts.Count == 0) return obj;
            var field = new Field(name: parts[0][1].Value, value: (object)null, index: parts[0][2].Value);
            try
            {
                field.Value = obj.GetType().GetField(field.Name, flags).GetValue(obj);
            }
            catch (NullReferenceException ex)
            {
                throw new Exception($"Wrong path provided: field '{field.Name}' does not exist on '{obj}'");
            }
            field = TrySetEnumerableValue(field);
            return GetFieldValueByPathParts(field.Value, parts.Skip(1).ToList(), flags);
        }
        private static Field TrySetEnumerableValue(Field field)
        {
            if (field.Value != null && field.Index != null)
            {
                var enumerable = ((IEnumerable)field.Value).Cast<object>();
                field.Value = field.Index <= enumerable.Count() ? enumerable.ElementAt(field.Index.Value) : null;
            }
            return field;
        }
    }
    
    public class Field
    {
        public string Name { get; set; }
        public object Value { get; set; }
        public int? Index { get; set; }
        public Field(string name, object value, string index)
        {
            Name = name;
            Value = value;
            Index = int.TryParse(index, out int parsed) ? parsed : (int?)null;
        }
    }

public class A
    {
       private B b;
       public A(B b) { this.b = b; }
    }

public class B
    {
       private C[] cItems;
       public B(C[] cItems) { this.cItems = cItems; }
    }

public class C
    {
       private int target; // <-- get this value
       public C(int val) { this.target = val; }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,31 sec, absolute running time: 0,2 sec, cpu time: 0,22 sec, average memory usage: 20 Mb, average nr of threads: 4, absolute service time: 0,55 sec