Implement processing parameters

Author: a-gubskiy

src/BitzArt.XDoc/Utility/XmlParser.cs

@@ -75,20 +75,18 @@ private TypeDocumentation ParseTypeNode(XmlNode node, string name)
 
     private PropertyDocumentation ParsePropertyNode(XmlNode node, string name)
         => ParseMemberNode(name,
-            (type, memberName) => type.GetProperty(memberName),
+            (type, memberName, paramaters) => type.GetProperty(memberName),
             member => new PropertyDocumentation(_source, member, node));
 
     private FieldDocumentation ParseFieldNode(XmlNode node, string name)
         => ParseMemberNode(name,
-            (type, memberName) => type.GetField(memberName),
+            (type, memberName, parameters) => type.GetField(memberName),
             member => new FieldDocumentation(_source, member, node));
 
     private MethodDocumentation? ParseMethodNode(XmlNode node, string name)
         => ParseMemberNode(name,
-            (type, memberName) =>
+            (type, memberName, parameters) =>
             {
-                var parameters = GetMethodParameters(memberName);
-
                 return type.GetMethods()
                     .Where(method => method.Name == memberName)
                     .Where(method =>
@@ -114,13 +112,14 @@ private FieldDocumentation ParseFieldNode(XmlNode node, string name)
             },
             member => new MethodDocumentation(_source, member, node));
 
-    private TDocumentation ParseMemberNode<TMember, TDocumentation>(string name, Func<Type, string, TMember?> getMember, Func<TMember, TDocumentation> getDocumentation)
+    private TDocumentation ParseMemberNode<TMember, TDocumentation>(string name, Func<Type, string, IReadOnlyCollection<string>, TMember?> getMember, Func<TMember, TDocumentation> getDocumentation)
         where TMember : MemberInfo
         where TDocumentation : MemberDocumentation<TMember>
     {
         var (type, memberName) = ResolveTypeAndMemberName(name);
+        var parameters = ResolveMethodParameters(name);
 
-        var memberInfo = getMember.Invoke(type, memberName)
+        var memberInfo = getMember.Invoke(type, memberName, parameters)
             ?? throw new InvalidOperationException(
                 $"Member '{memberName}' not found in type '{type.Name}'.");
 
@@ -133,6 +132,39 @@ private TDocumentation ParseMemberNode<TMember, TDocumentation>(string name, Fun
         return memberDocumentation;
     }
 
+    private static IReadOnlyCollection<string> ResolveMethodParameters(string name)
+    {
+        var startIndex = name.IndexOf('(');
+        
+        if (startIndex == -1)
+        {
+            return Array.Empty<string>();
+        }
+    
+        var endIndex = name.LastIndexOf(')');
+
+        if (endIndex <= startIndex)
+        {
+            return Array.Empty<string>();
+        }
+    
+        var parametersString = name.Substring(startIndex + 1, endIndex - startIndex - 1);
+        
+        if (string.IsNullOrWhiteSpace(parametersString))
+        {
+            return Array.Empty<string>();
+        }
+
+        var result = parametersString
+            .Split(',', StringSplitOptions.RemoveEmptyEntries)
+            .Select(p => p.Trim())
+            .Select(p => p.Replace("`0", ""))
+            .Select(p => p.Replace("`", ""))
+            .ToList();
+        
+        return result;
+    }
+
     /// <summary>
     /// Get the friendly name of a type
     /// </summary>
@@ -166,35 +198,6 @@ private static string GetTypeFriendlyName(Type type)
         return friendlyName;
     }
 
-    // Fetches the parameter type names of a method from the XML documentation.
-    private static List<string> GetMethodParameters(string xmlMember)
-    {
-        var start = xmlMember.IndexOf('(');
-        var end = xmlMember.LastIndexOf(')');
-
-        if (start == -1 || end == -1 || end <= start)
-        {
-            return [];
-        }
-
-        // Extract the substring that contains the parameters.
-        var paramList = xmlMember.Substring(start + 1, end - start - 1);
-
-        if (string.IsNullOrWhiteSpace(paramList))
-        {
-            return [];
-        }
-
-        // Split the parameter list by commas and trim each parameter.
-        var methodParameters = paramList.Split([','], StringSplitOptions.RemoveEmptyEntries)
-            .Select(p => p.Trim())
-            .Select(p => p.Replace("`0", ""))
-            .Select(p => p.Replace("`", ""))
-            .ToList();
-
-        return methodParameters;
-    }
-
     private (Type type, string memberName) ResolveTypeAndMemberName(string name)
     {
         if (name.Contains('`'))

tests/BitzArt.XDoc.TestNodes/TestMemberNode.cs

@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Reflection;
 
 namespace BitzArt.XDoc.Tests;
@@ -8,6 +9,7 @@ public class TestMemberNode
     private readonly TestNodeType _type;
     private readonly string _name;
     private readonly string _content;
+    private readonly IReadOnlyCollection<ParameterInfo> _parameters;
 
     public TestMemberNode(Type type, string content)
         : this(TestNodeType.Type, type.FullName!, content) { }
@@ -19,21 +21,53 @@ public TestMemberNode(PropertyInfo property, string content)
         : this(TestNodeType.Property, GetMemberName(property), content) { }
 
     public TestMemberNode(MethodInfo method, string content)
-        : this(TestNodeType.Method, GetMemberName(method), content) { }
+        : this(TestNodeType.Method, GetMemberName(method), content) => 
+        _parameters = method.GetParameters();
 
     public TestMemberNode(TestNodeType type, string name, string content)
     {
         _type = type;
         _name = name;
         _content = content;
+        _parameters = ImmutableList<ParameterInfo>.Empty;
     }
 
-    public string GetXml() =>
-        $"""
-        <member name="{XmlNodeTypeChar}:{_name}">
-            {_content.Offset(4, exceptFirstLine: true)}
-        </member>
-        """;
+    public string GetXml()
+    {
+        var xml = "";
+
+        if (_type == TestNodeType.Method)
+        {
+            var parameters = string.Join(", ", _parameters.Select(Render));
+
+            xml = $"""
+                   <member name="{XmlNodeTypeChar}:{_name}({parameters})">
+                       {_content.Offset(4, exceptFirstLine: true)}
+                   </member>
+                   """;
+
+        }
+        else
+        {
+            xml = $"""
+                   <member name="{XmlNodeTypeChar}:{_name}">
+                       {_content.Offset(4, exceptFirstLine: true)}
+                   </member>
+                   """;
+        }
+
+        return xml;
+    }
+
+    private string Render(ParameterInfo p)
+    {
+        var type = p.ParameterType;
+        var typeName = type.FullName ?? type.Name;
+        
+        // Remove the generic parameter count indicators from the type name
+        // (e.g., List`1 becomes List)
+        return typeName.Replace("`0", "").Replace("`", "");
+    }
 
     private static string GetMemberName(MemberInfo member)
         => $"{member.DeclaringType!.FullName}.{member.Name}";

tests/BitzArt.XDoc.Tests/TestTypes/TestClass.cs

@@ -4,7 +4,7 @@ public class TestClass
 {
     public string TestProperty { get; set; } = null!;
 
-    public void TestMethod() { }
+    public void TestMethod(int a1, string b2) { }
 
     public string TestField = null!;
 }