Refactoring to improve cognitive complexity.

Author: tillig

src/Autofac/Core/Activators/Reflection/AutowiringPropertyInjector.cs

@@ -113,43 +113,59 @@ private static IEnumerable<PropertyInfo> GetInjectableProperties(Type instanceTy
     {
         foreach (var property in instanceType.GetRuntimeProperties())
         {
-            if (!property.CanWrite)
+            if (!IsInjectableProperty(property))
             {
                 continue;
             }
 
-            // SetMethod will be non-null if CanWrite is true.
-            // Don't want to inject onto static properties.
-            if (property.SetMethod!.IsStatic)
-            {
-                continue;
-            }
+            yield return property;
+        }
+    }
 
-            var propertyType = property.PropertyType;
+    private static bool IsInjectableProperty(PropertyInfo property)
+    {
+        // We only inject into assignable instance properties.
+        if (!property.CanWrite)
+        {
+            return false;
+        }
 
-            if (propertyType.IsValueType && !propertyType.IsEnum)
-            {
-                continue;
-            }
+        // SetMethod will be non-null if CanWrite is true.
+        // Don't want to inject onto static properties.
+        if (property.SetMethod!.IsStatic)
+        {
+            return false;
+        }
 
-            // GetElementType will be non-null if IsArray is true.
-            if (propertyType.IsArray && propertyType.GetElementType()!.IsValueType)
-            {
-                continue;
-            }
+        // Avoid attempting resolution for value-type shapes that Autofac does not
+        // meaningfully construct via property injection.
+        var propertyType = property.PropertyType;
+        if (IsUnsupportedPropertyType(propertyType))
+        {
+            return false;
+        }
 
-            if (propertyType.IsGenericEnumerableInterfaceType() && propertyType.GenericTypeArguments[0].IsValueType)
-            {
-                continue;
-            }
+        // Indexers require index arguments and are not regular injectable properties.
+        return property.GetIndexParameters().Length == 0;
+    }
 
-            if (property.GetIndexParameters().Length != 0)
-            {
-                continue;
-            }
+    private static bool IsUnsupportedPropertyType(Type propertyType)
+    {
+        // Primitive/value-type properties are not autowired (enums are allowed).
+        if (propertyType.IsValueType && !propertyType.IsEnum)
+        {
+            return true;
+        }
 
-            yield return property;
+        // Arrays of value types behave like value containers; skip autowiring.
+        // GetElementType will be non-null if IsArray is true.
+        if (propertyType.IsArray && propertyType.GetElementType()!.IsValueType)
+        {
+            return true;
         }
+
+        // Also skip IEnumerable<TValueType> - same rule as arrays above.
+        return propertyType.IsGenericEnumerableInterfaceType() && propertyType.GenericTypeArguments[0].IsValueType;
     }
 
     [SuppressMessage("S125", "S125", Justification = "Commented code explains the code generation output.")]