Allow selecting static properties or fields (#17)

Dennis Doomen · web-flow · commit 95b2fba57558 · 2024-11-16T21:44:46.000+01:00
diff --git a/README.md b/README.md
@@ -31,7 +31,7 @@ var properties = typeof(SuperClass).GetProperties(
     MemberKind.Public | MemberKind.ExplicitlyImplemented | MemberKind.DefaultInterfaceProperties);
 ```
 
-You can take any of the options `Public`, `Internal`, `ExplictlyImplemented` and `DefaultInterfaceProperties`.
+You can take any of the options `Public`, `Internal`, `Static`, `ExplictlyImplemented` and `DefaultInterfaceProperties`.
 
 If you need the fields, use `GetFields` (which obviously cannot be explicitly implemented, nor be part of interfaces), and if you need the members, use `GetMembers`. You can also request individual members by name, like `GetProperty("Name", MemberKind.Public)` or `GetField("Name", MemberKind.Internal)`.
 
diff --git a/src/Reflectify/Reflectify.cs b/src/Reflectify/Reflectify.cs
@@ -535,7 +535,8 @@ internal enum MemberKind
     Public = 1,
     Internal = 2,
     ExplicitlyImplemented = 4,
-    DefaultInterfaceProperties = 8
+    DefaultInterfaceProperties = 8,
+    Static = 16
 }
 
 internal static class MemberKindExtensions
@@ -564,37 +565,38 @@ public static BindingFlags ToBindingFlags(this MemberKind kind)
 internal sealed class Reflector
 {
     private readonly HashSet<string> collectedPropertyNames = new();
-    private readonly HashSet<string> collectedFields = new();
-    private readonly List<FieldInfo> fields = new();
-    private List<PropertyInfo> properties = new();
+    private readonly HashSet<string> collectedFieldNames = new();
+    private readonly List<FieldInfo> selectedFields = new();
+    private List<PropertyInfo> selectedProperties = new();
 
     public Reflector(Type typeToReflect, MemberKind kind)
     {
         LoadProperties(typeToReflect, kind);
         LoadFields(typeToReflect, kind);
 
-        Members = properties.Concat<MemberInfo>(fields).ToArray();
+        Members = selectedProperties.Concat<MemberInfo>(selectedFields).ToArray();
     }
 
     private void LoadProperties(Type typeToReflect, MemberKind kind)
     {
         while (typeToReflect != null && typeToReflect != typeof(object))
         {
-            var allProperties = typeToReflect.GetProperties(
-                BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly | BindingFlags.Public |
-                BindingFlags.NonPublic);
+            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);
 
             AddExplicitlyImplementedProperties(kind, allProperties);
 
-            AddInterfaceProperties(typeToReflect, kind);
+            AddInterfaceProperties(typeToReflect, kind, flags);
 
             // Move to the base type
             typeToReflect = typeToReflect.BaseType;
         }
 
-        properties = properties.Where(x => !x.IsIndexer()).ToList();
+        selectedProperties = selectedProperties.Where(x => !x.IsIndexer()).ToList();
     }
 
     private void AddNormalProperties(MemberKind kind, PropertyInfo[] allProperties)
@@ -607,7 +609,7 @@ private void AddNormalProperties(MemberKind kind, PropertyInfo[] allProperties)
                 if (!collectedPropertyNames.Contains(property.Name) && !property.IsExplicitlyImplemented() &&
                     HasVisibility(kind, property))
                 {
-                    properties.Add(property);
+                    selectedProperties.Add(property);
                     collectedPropertyNames.Add(property.Name);
                 }
             }
@@ -633,29 +635,28 @@ private void AddExplicitlyImplementedProperties(MemberKind kind, PropertyInfo[]
 
                     if (!collectedPropertyNames.Contains(name))
                     {
-                        properties.Add(p);
+                        selectedProperties.Add(p);
                         collectedPropertyNames.Add(name);
                     }
                 }
             }
         }
     }
 
-    private void AddInterfaceProperties(Type typeToReflect, MemberKind kind)
+    private void AddInterfaceProperties(Type typeToReflect, MemberKind kind, BindingFlags flags)
     {
         if (kind.HasFlag(MemberKind.DefaultInterfaceProperties) || typeToReflect.IsInterface)
         {
-            // Add explicitly implemented interface properties (not included above)
             var interfaces = typeToReflect.GetInterfaces();
 
             foreach (var iface in interfaces)
             {
-                foreach (var prop in iface.GetProperties())
+                foreach (var prop in iface.GetProperties(flags))
                 {
                     if (!collectedPropertyNames.Contains(prop.Name) &&
                         (!prop.GetMethod.IsAbstract || typeToReflect.IsInterface))
                     {
-                        properties.Add(prop);
+                        selectedProperties.Add(prop);
                         collectedPropertyNames.Add(prop.Name);
                     }
                 }
@@ -667,15 +668,17 @@ private void LoadFields(Type typeToReflect, MemberKind kind)
     {
         while (typeToReflect != null && typeToReflect != typeof(object))
         {
-            var files = typeToReflect.GetFields(
-                BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic);
+            BindingFlags flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic;
+            flags |= kind.HasFlag(MemberKind.Static) ? BindingFlags.Static : BindingFlags.Instance;
+
+            var files = typeToReflect.GetFields(flags);
 
             foreach (var field in files)
             {
-                if (!collectedFields.Contains(field.Name) && HasVisibility(kind, field))
+                if (!collectedFieldNames.Contains(field.Name) && HasVisibility(kind, field))
                 {
-                    fields.Add(field);
-                    collectedFields.Add(field.Name);
+                    selectedFields.Add(field);
+                    collectedFieldNames.Add(field.Name);
                 }
             }
 
@@ -692,7 +695,7 @@ private static bool HasVisibility(MemberKind kind, FieldInfo field)
 
     public MemberInfo[] Members { get; }
 
-    public PropertyInfo[] Properties => properties.ToArray();
+    public PropertyInfo[] Properties => selectedProperties.ToArray();
 
-    public FieldInfo[] Fields => fields.ToArray();
+    public FieldInfo[] Fields => selectedFields.ToArray();
 }
diff --git a/tests/Reflectify.Specs/TypeMemberExtensionsSpecs.cs b/tests/Reflectify.Specs/TypeMemberExtensionsSpecs.cs
@@ -11,7 +11,7 @@ public class TypeMemberExtensionsSpecs
     public class GetPropertiesAndFields
     {
         [Fact]
-        public void Can_get_all_public_explicit_and_default_interface_properties()
+        public void Can_get_all_public_explicit_and_default_instance_interface_properties()
         {
             // Act
             var properties = typeof(SuperClass).GetProperties(
@@ -23,7 +23,6 @@ public void Can_get_all_public_explicit_and_default_interface_properties()
                 new { Name = "NormalProperty", PropertyType = typeof(string) },
                 new { Name = "NewProperty", PropertyType = typeof(int) },
                 new { Name = "InterfaceProperty", PropertyType = typeof(string) },
-                new { Name = "StaticProperty", PropertyType = typeof(bool) },
                 new
                 {
                     Name =
@@ -36,6 +35,19 @@ public void Can_get_all_public_explicit_and_default_interface_properties()
             });
         }
 
+        [Fact]
+        public void Can_get_all_public_static_properties()
+        {
+            // Act
+            var properties = typeof(SuperClass).GetProperties(
+                MemberKind.Public | MemberKind.Static);
+
+            // Assert
+            properties.Should().BeEquivalentTo([
+                new { Name = "StaticProperty", PropertyType = typeof(bool) }
+            ]);
+        }
+
         [Fact]
         public void Can_get_all_properties_from_an_interface()
         {
@@ -64,7 +76,6 @@ public void Can_get_normal_public_properties()
             {
                 new { Name = "NormalProperty", PropertyType = typeof(string) },
                 new { Name = "NewProperty", PropertyType = typeof(int) },
-                new { Name = "StaticProperty", PropertyType = typeof(bool) },
                 new { Name = "InterfaceProperty", PropertyType = typeof(string) }
             });
         }
@@ -217,7 +228,6 @@ public void Can_find_all_members()
                 new { Name = "NormalProperty" },
                 new { Name = "NewProperty" },
                 new { Name = "InterfaceProperty" },
-                new { Name = "StaticProperty" },
                 new { Name = "NormalField" },
             ]);
         }
@@ -394,7 +404,7 @@ public void Can_find_an_internal_indexer_if_you_ask_for_ot()
     public class FindField
     {
         [Fact]
-        public void Can_find_a_public_field()
+        public void Can_find_a_public_instance_field()
         {
             // Act
             var field = typeof(SuperClass).FindField("NormalField", MemberKind.Public);
@@ -409,12 +419,34 @@ public void Can_find_a_public_field()
         public void Cannot_find_a_field_if_it_does_not_exist()
         {
             // Act
-            var field = typeof(SuperClass).FindField("NonExistingProperty", MemberKind.Public);
+            var field = typeof(SuperClass).FindField("NonExistingField", MemberKind.Public);
 
             // Assert
             field.Should().BeNull();
         }
 
+        [Fact]
+        public void Cannot_find_a_static_field_if_you_dont_ask_for_it()
+        {
+            // Act
+            var field = typeof(SuperClass).FindField("StaticField", MemberKind.Public);
+
+            // Assert
+            field.Should().BeNull();
+        }
+
+        [Fact]
+        public void Can_find_a_static_field_if_you_ask_for_it()
+        {
+            // Act
+            var field = typeof(SuperClass).FindField("StaticField", MemberKind.Public | MemberKind.Static);
+
+            // Assert
+            field.Should().NotBeNull();
+            field.Name.Should().Be("StaticField");
+            field.FieldType.Should().Be<bool>();
+        }
+
         [Theory]
         [InlineData("")]
         [InlineData(null)]

Original file line number	Diff line number	Diff line change
`@@ -535,7 +535,8 @@ internal enum MemberKind`
`535`	`535`	`Public = 1,`
`536`	`536`	`Internal = 2,`
`537`	`537`	`ExplicitlyImplemented = 4,`
`538`		`- DefaultInterfaceProperties = 8`
	`538`	`+ DefaultInterfaceProperties = 8,`
	`539`	`+ Static = 16`
`539`	`540`	`}`
`540`	`541`
`541`	`542`	`internal static class MemberKindExtensions`
`@@ -564,37 +565,38 @@ public static BindingFlags ToBindingFlags(this MemberKind kind)`
`564`	`565`	`internal sealed class Reflector`
`565`	`566`	`{`
`566`	`567`	`private readonly HashSet<string> collectedPropertyNames = new();`
`567`		`- private readonly HashSet<string> collectedFields = new();`
`568`		`- private readonly List<FieldInfo> fields = new();`
`569`		`- private List<PropertyInfo> properties = new();`
	`568`	`+ private readonly HashSet<string> collectedFieldNames = new();`
	`569`	`+ private readonly List<FieldInfo> selectedFields = new();`
	`570`	`+ private List<PropertyInfo> selectedProperties = new();`
`570`	`571`
`571`	`572`	`public Reflector(Type typeToReflect, MemberKind kind)`
`572`	`573`	`{`
`573`	`574`	`LoadProperties(typeToReflect, kind);`
`574`	`575`	`LoadFields(typeToReflect, kind);`
`575`	`576`
`576`		`- Members = properties.Concat<MemberInfo>(fields).ToArray();`
	`577`	`+ Members = selectedProperties.Concat<MemberInfo>(selectedFields).ToArray();`
`577`	`578`	`}`
`578`	`579`
`579`	`580`	`private void LoadProperties(Type typeToReflect, MemberKind kind)`
`580`	`581`	`{`
`581`	`582`	`while (typeToReflect != null && typeToReflect != typeof(object))`
`582`	`583`	`{`
`583`		`- var allProperties = typeToReflect.GetProperties(`
`584`		`- BindingFlags.Instance \| BindingFlags.Static \| BindingFlags.DeclaredOnly \| BindingFlags.Public \|`
`585`		`- BindingFlags.NonPublic);`
	`584`	`+ BindingFlags flags = BindingFlags.DeclaredOnly \| BindingFlags.Public \| BindingFlags.NonPublic;`
	`585`	`+ flags \|= kind.HasFlag(MemberKind.Static) ? BindingFlags.Static : BindingFlags.Instance;`
	`586`	`+`
	`587`	`+ var allProperties = typeToReflect.GetProperties(flags);`
`586`	`588`
`587`	`589`	`AddNormalProperties(kind, allProperties);`
`588`	`590`
`589`	`591`	`AddExplicitlyImplementedProperties(kind, allProperties);`
`590`	`592`
`591`		`- AddInterfaceProperties(typeToReflect, kind);`
	`593`	`+ AddInterfaceProperties(typeToReflect, kind, flags);`
`592`	`594`
`593`	`595`	`// Move to the base type`
`594`	`596`	`typeToReflect = typeToReflect.BaseType;`
`595`	`597`	`}`
`596`	`598`
`597`		`- properties = properties.Where(x => !x.IsIndexer()).ToList();`
	`599`	`+ selectedProperties = selectedProperties.Where(x => !x.IsIndexer()).ToList();`
`598`	`600`	`}`
`599`	`601`
`600`	`602`	`private void AddNormalProperties(MemberKind kind, PropertyInfo[] allProperties)`
`@@ -607,7 +609,7 @@ private void AddNormalProperties(MemberKind kind, PropertyInfo[] allProperties)`
`607`	`609`	`if (!collectedPropertyNames.Contains(property.Name) && !property.IsExplicitlyImplemented() &&`
`608`	`610`	`HasVisibility(kind, property))`
`609`	`611`	`{`
`610`		`- properties.Add(property);`
	`612`	`+ selectedProperties.Add(property);`
`611`	`613`	`collectedPropertyNames.Add(property.Name);`
`612`	`614`	`}`
`613`	`615`	`}`
`@@ -633,29 +635,28 @@ private void AddExplicitlyImplementedProperties(MemberKind kind, PropertyInfo[]`
`633`	`635`
`634`	`636`	`if (!collectedPropertyNames.Contains(name))`
`635`	`637`	`{`
`636`		`- properties.Add(p);`
	`638`	`+ selectedProperties.Add(p);`
`637`	`639`	`collectedPropertyNames.Add(name);`
`638`	`640`	`}`
`639`	`641`	`}`
`640`	`642`	`}`
`641`	`643`	`}`
`642`	`644`	`}`
`643`	`645`
`644`		`- private void AddInterfaceProperties(Type typeToReflect, MemberKind kind)`
	`646`	`+ private void AddInterfaceProperties(Type typeToReflect, MemberKind kind, BindingFlags flags)`
`645`	`647`	`{`
`646`	`648`	`if (kind.HasFlag(MemberKind.DefaultInterfaceProperties) \|\| typeToReflect.IsInterface)`
`647`	`649`	`{`
`648`		`- // Add explicitly implemented interface properties (not included above)`
`649`	`650`	`var interfaces = typeToReflect.GetInterfaces();`
`650`	`651`
`651`	`652`	`foreach (var iface in interfaces)`
`652`	`653`	`{`
`653`		`- foreach (var prop in iface.GetProperties())`
	`654`	`+ foreach (var prop in iface.GetProperties(flags))`
`654`	`655`	`{`
`655`	`656`	`if (!collectedPropertyNames.Contains(prop.Name) &&`
`656`	`657`	`(!prop.GetMethod.IsAbstract \|\| typeToReflect.IsInterface))`
`657`	`658`	`{`
`658`		`- properties.Add(prop);`
	`659`	`+ selectedProperties.Add(prop);`
`659`	`660`	`collectedPropertyNames.Add(prop.Name);`
`660`	`661`	`}`
`661`	`662`	`}`
`@@ -667,15 +668,17 @@ private void LoadFields(Type typeToReflect, MemberKind kind)`
`667`	`668`	`{`
`668`	`669`	`while (typeToReflect != null && typeToReflect != typeof(object))`
`669`	`670`	`{`
`670`		`- var files = typeToReflect.GetFields(`
`671`		`- BindingFlags.Instance \| BindingFlags.DeclaredOnly \| BindingFlags.Public \| BindingFlags.NonPublic);`
	`671`	`+ BindingFlags flags = BindingFlags.DeclaredOnly \| BindingFlags.Public \| BindingFlags.NonPublic;`
	`672`	`+ flags \|= kind.HasFlag(MemberKind.Static) ? BindingFlags.Static : BindingFlags.Instance;`
	`673`	`+`
	`674`	`+ var files = typeToReflect.GetFields(flags);`
`672`	`675`
`673`	`676`	`foreach (var field in files)`
`674`	`677`	`{`
`675`		`- if (!collectedFields.Contains(field.Name) && HasVisibility(kind, field))`
	`678`	`+ if (!collectedFieldNames.Contains(field.Name) && HasVisibility(kind, field))`
`676`	`679`	`{`
`677`		`- fields.Add(field);`
`678`		`- collectedFields.Add(field.Name);`
	`680`	`+ selectedFields.Add(field);`
	`681`	`+ collectedFieldNames.Add(field.Name);`
`679`	`682`	`}`
`680`	`683`	`}`
`681`	`684`
`@@ -692,7 +695,7 @@ private static bool HasVisibility(MemberKind kind, FieldInfo field)`
`692`	`695`
`693`	`696`	`public MemberInfo[] Members { get; }`
`694`	`697`
`695`		`- public PropertyInfo[] Properties => properties.ToArray();`
	`698`	`+ public PropertyInfo[] Properties => selectedProperties.ToArray();`
`696`	`699`
`697`		`- public FieldInfo[] Fields => fields.ToArray();`
	`700`	`+ public FieldInfo[] Fields => selectedFields.ToArray();`
`698`	`701`	`}`