Directory.Build.props

@@ -32,11 +32,11 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Roslynator.Analyzers" Version="4.12.10">
+    <PackageReference Include="Roslynator.Analyzers" Version="4.13.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Meziantou.Analyzer" Version="2.0.186">
+    <PackageReference Include="Meziantou.Analyzer" Version="2.0.188">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

build/_build.csproj

@@ -12,8 +12,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Nuke.Common" Version="9.0.3" />
-    <PackageReference Include="Nuke.Components" Version="9.0.3" />
+    <PackageReference Include="Nuke.Common" Version="9.0.4" />
+    <PackageReference Include="Nuke.Components" Version="9.0.4" />
     <PackageDownload Include="ReportGenerator" Version="[5.2.0]" />
     <PackageDownload Include="GitVersion.Tool" Version="[6.0.2]" />
   </ItemGroup>

src/Reflectify/Reflectify.cs

@@ -6,6 +6,7 @@
 #nullable disable
 
 using System;
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -599,7 +600,7 @@ public static BindingFlags ToBindingFlags(this MemberKind kind)
 internal sealed class Reflector
 {
     private readonly List<FieldInfo> selectedFields = new();
-    private List<PropertyInfo> selectedProperties = new();
+    private readonly OrderedPropertyCollection selectedProperties = new();
 
     public Reflector(Type typeToReflect, MemberKind kind)
     {
@@ -611,40 +612,34 @@ public Reflector(Type typeToReflect, MemberKind kind)
 
     private void LoadProperties(Type typeToReflect, MemberKind kind)
     {
-        var collectedPropertyNames = new HashSet<string>();
-
         while (typeToReflect != null && typeToReflect != typeof(object))
         {
             BindingFlags flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic;
             flags |= kind.HasFlag(MemberKind.Static) ? BindingFlags.Static : BindingFlags.Instance;
 
             var allProperties = typeToReflect.GetProperties(flags);
 
-            AddNormalProperties(kind, allProperties, collectedPropertyNames);
+            AddNormalProperties(kind, allProperties);
 
-            AddExplicitlyImplementedProperties(kind, allProperties, collectedPropertyNames);
+            AddExplicitlyImplementedProperties(kind, allProperties);
 
-            AddInterfaceProperties(typeToReflect, kind, flags, collectedPropertyNames);
+            AddInterfaceProperties(typeToReflect, kind, flags);
 
             // Move to the base type
             typeToReflect = typeToReflect.BaseType;
         }
-
-        selectedProperties = selectedProperties.Where(x => !x.IsIndexer()).ToList();
     }
 
-    private void AddNormalProperties(MemberKind kind, PropertyInfo[] allProperties,
-        HashSet<string> collectedPropertyNames)
+    private void AddNormalProperties(MemberKind kind, PropertyInfo[] allProperties)
     {
         if (kind.HasFlag(MemberKind.Public) || kind.HasFlag(MemberKind.Internal) ||
             kind.HasFlag(MemberKind.ExplicitlyImplemented))
         {
             foreach (var property in allProperties)
             {
-                if (HasVisibility(kind, property) && !property.IsExplicitlyImplemented() &&
-                    collectedPropertyNames.Add(property.Name))
+                if (HasVisibility(kind, property) && !property.IsExplicitlyImplemented())
                 {
-                    selectedProperties.Add(property);
+                    selectedProperties.AddNormal(property);
                 }
             }
         }
@@ -656,29 +651,22 @@ private static bool HasVisibility(MemberKind kind, PropertyInfo prop)
                (kind.HasFlag(MemberKind.Internal) && prop.IsInternal());
     }
 
-    private void AddExplicitlyImplementedProperties(MemberKind kind, PropertyInfo[] allProperties,
-        HashSet<string> collectedPropertyNames)
+    private void AddExplicitlyImplementedProperties(MemberKind kind, PropertyInfo[] allProperties)
     {
         if (kind.HasFlag(MemberKind.ExplicitlyImplemented))
         {
-            foreach (var p in allProperties)
+            foreach (var property in allProperties)
             {
-                if (p.IsExplicitlyImplemented())
+                if (property.IsExplicitlyImplemented())
                 {
-                    var name = p.Name.Split('.').Last();
-
-                    if (collectedPropertyNames.Add(name))
-                    {
-                        selectedProperties.Add(p);
-                    }
+                    selectedProperties.AddExplicitlyImplemented(property);
                 }
             }
         }
     }
 
 #pragma warning disable AV1561
-    private void AddInterfaceProperties(Type typeToReflect, MemberKind kind, BindingFlags flags,
-        HashSet<string> collectedPropertyNames)
+    private void AddInterfaceProperties(Type typeToReflect, MemberKind kind, BindingFlags flags)
     {
         if (kind.HasFlag(MemberKind.DefaultInterfaceProperties) || typeToReflect.IsInterface)
         {
@@ -688,10 +676,9 @@ private void AddInterfaceProperties(Type typeToReflect, MemberKind kind, Binding
             {
                 foreach (var prop in interfaceType.GetProperties(flags))
                 {
-                    if ((!prop.IsAbstract() || typeToReflect.IsInterface) &&
-                        collectedPropertyNames.Add(prop.Name))
+                    if (!prop.IsAbstract() || typeToReflect.IsInterface)
                     {
-                        selectedProperties.Add(prop);
+                        selectedProperties.AddFromInterface(prop);
                     }
                 }
             }
@@ -734,4 +721,68 @@ private static bool HasVisibility(MemberKind kind, FieldInfo field)
     public PropertyInfo[] Properties => selectedProperties.ToArray();
 
     public FieldInfo[] Fields => selectedFields.ToArray();
+
+    private class OrderedPropertyCollection : IEnumerable<PropertyInfo>
+    {
+        private readonly Dictionary<string, PropertyKind> kindMap = new();
+        private readonly List<(string Name, PropertyInfo Property)> propertiesWithName = new();
+
+        public IEnumerator<PropertyInfo> GetEnumerator()
+        {
+            return propertiesWithName.Select(x => x.Property).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        private enum PropertyKind
+        {
+            Normal,
+            ExplicitlyImplemented,
+            Interface
+        }
+
+        public void AddExplicitlyImplemented(PropertyInfo property)
+        {
+            var name = property.Name.Split('.').Last();
+
+            Add(name, property, PropertyKind.ExplicitlyImplemented);
+        }
+
+        public void AddNormal(PropertyInfo property)
+        {
+            Add(property.Name, property, PropertyKind.Normal);
+        }
+
+        public void AddFromInterface(PropertyInfo property)
+        {
+            Add(property.Name, property, PropertyKind.Interface);
+        }
+
+        private void Add(string name, PropertyInfo property, PropertyKind kind)
+        {
+            if (property.IsIndexer())
+            {
+                // We explicitly skip indexers
+            }
+            else if (!kindMap.TryGetValue(name, out var existingKind))
+            {
+                kindMap[name] = kind;
+                propertiesWithName.Add((name, property));
+            }
+            else if (existingKind == PropertyKind.ExplicitlyImplemented && kind == PropertyKind.Normal)
+            {
+                // Normal properties have priority over interface properties
+                kindMap[name] = kind;
+                propertiesWithName.RemoveAll(x => x.Name == name);
+                propertiesWithName.Add((name, property));
+            }
+            else
+            {
+                // Property with that name already exists
+            }
+        }
+    }
 }

tests/.editorconfig

@@ -1,5 +1,10 @@
 [*.cs]
 
+
+# Purpose: Do not expose generic lists
+# Reason: We don't care about this in tests
+dotnet_diagnostic.CA1002.severity = none
+
 # Purpose: Do not nest type GetProperties. 
 # Reason: We don't care about this in tests
 dotnet_diagnostic.CA1034.severity = none
@@ -32,6 +37,10 @@ dotnet_diagnostic.CA1822.severity = none
 # Reason: We don't care about this in tests
 dotnet_diagnostic.CA1852.severity = none
 
+# Prefer using collection abstraction instead of implementation
+# Reason: We don't care about this in tests
+dotnet_diagnostic.MA0016.severity = none
+
 # Purpose: Elements must be documented
 # Reason: Not needed for tests
 dotnet_diagnostic.SA1600.severity = none

tests/Reflectify.Specs/Reflectify.Specs.csproj

@@ -9,7 +9,7 @@
     </PropertyGroup>
 
     <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
-      <PackageReference Include="xunit.runner.visualstudio" Version="3.0.0">
+      <PackageReference Include="xunit.runner.visualstudio" Version="3.0.2">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
       </PackageReference>
@@ -25,7 +25,7 @@
 
     <ItemGroup Condition="'$(TargetFramework)' == 'net6.0'">
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />
-      <PackageReference Include="xunit.runner.visualstudio" Version="3.0.0">
+      <PackageReference Include="xunit.runner.visualstudio" Version="3.0.2">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
       </PackageReference>
@@ -36,10 +36,10 @@
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
-      <PackageReference Include="xunit" Version="2.5.0" />
-      <PackageReference Include="FluentAssertions" Version="7.0.0-alpha.5" />
+      <PackageReference Include="xunit" Version="2.9.3" />
+      <PackageReference Include="FluentAssertions" Version="8.1.1" />
       <PackageReference Include="JetBrains.Annotations" Version="2024.3.0" />
-      <PackageReference Include="coverlet.collector" Version="6.0.2" PrivateAssets="all">
+      <PackageReference Include="coverlet.collector" Version="6.0.4" PrivateAssets="all">
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       </PackageReference>
       </ItemGroup>

tests/Reflectify.Specs/TypeMemberExtensionsSpecs.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using FluentAssertions;
 using JetBrains.Annotations;
@@ -244,6 +245,33 @@ public void Can_find_all_members()
                 new { Name = "NormalField" },
             ]);
         }
+
+        private interface ICollectionInterface
+        {
+            [UsedImplicitly]
+            IReadOnlyCollection<int> Items { get; }
+        }
+
+        private abstract class BaseCollection
+        {
+            public List<int> Items { get; } = new();
+        }
+
+        private sealed class CollectionImplementation : BaseCollection, ICollectionInterface
+        {
+            IReadOnlyCollection<int> ICollectionInterface.Items => Items;
+        }
+
+        [Fact]
+        public void Normal_properties_are_always_preferred_over_explicit_properties()
+        {
+            var properties = typeof(CollectionImplementation).GetProperties(
+                MemberKind.Public | MemberKind.ExplicitlyImplemented);
+
+            properties.Should().BeEquivalentTo([
+                new { Name = "Items", PropertyType = typeof(List<int>) }
+            ]);
+        }
     }
 
     public class FindProperty