refactor code

Author: StefH

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -680,18 +680,7 @@ private Expression ParseComparisonOperator()
 
     private static bool HasImplicitConversion(Type baseType, Type targetType)
     {
-        var baseTypeHasConversion = baseType.GetMethods(BindingFlags.Public | BindingFlags.Static)
-            .Where(mi => mi.Name == "op_Implicit" && mi.ReturnType == targetType)
-            .Any(mi => mi.GetParameters().FirstOrDefault()?.ParameterType == baseType);
-
-        if (baseTypeHasConversion)
-        {
-            return true;
-        }
-
-        return targetType.GetMethods(BindingFlags.Public | BindingFlags.Static)
-            .Where(mi => mi.Name == "op_Implicit" && mi.ReturnType == targetType)
-            .Any(mi => mi.GetParameters().FirstOrDefault()?.ParameterType == baseType);
+        return TypeHelper.TryGetImplicitConversionOperatorMethod(baseType, targetType, out _);
     }
 
     private static ConstantExpression ParseEnumToConstantExpression(int pos, Type leftType, ConstantExpression constantExpr)

src/System.Linq.Dynamic.Core/Parser/ExpressionPromoter.cs

@@ -1,6 +1,5 @@
 using System.Linq.Expressions;
 using System.Reflection;
-using System.Linq;
 
 namespace System.Linq.Dynamic.Core.Parser;
 
@@ -136,26 +135,7 @@ public ExpressionPromoter(ParsingConfig config)
             return sourceExpression;
         }
 
-        // Check for implicit conversion operators (op_Implicit) from returnType to type.
-        // Look for op_Implicit on the source type or the target type.
-        var implicitOperator =
-            returnType.GetMethods(BindingFlags.Public | BindingFlags.Static)
-                .FirstOrDefault(m =>
-                {
-                    if (m.Name != "op_Implicit" || m.ReturnType != type) return false;
-                    var parameters = m.GetParameters();
-                    return parameters.Length == 1 && parameters[0].ParameterType == returnType;
-                })
-            ??
-            type.GetMethods(BindingFlags.Public | BindingFlags.Static)
-                .FirstOrDefault(m =>
-                {
-                    if (m.Name != "op_Implicit" || m.ReturnType != type) return false;
-                    var parameters = m.GetParameters();
-                    return parameters.Length == 1 && parameters[0].ParameterType == returnType;
-                });
-
-        if (implicitOperator != null)
+        if (TypeHelper.TryGetImplicitConversionOperatorMethod(returnType, type, out _))
         {
             return Expression.Convert(sourceExpression, type);
         }

src/System.Linq.Dynamic.Core/Parser/TypeHelper.cs

@@ -533,4 +533,31 @@ public static bool IsDictionary(Type? type)
             TryFindGenericType(typeof(IReadOnlyDictionary<,>), type, out _);
 #endif
     }
+
+    /// <summary>
+    /// Check for implicit conversion operators (op_Implicit) from returnType to type.
+    /// Look for op_Implicit on the source type or the target type.
+    /// </summary>
+    public static bool TryGetImplicitConversionOperatorMethod(Type returnType, Type type, [NotNullWhen(true)] out MethodBase? implicitOperator)
+    {
+        const string methodName = "op_Implicit";
+
+        implicitOperator = Find(returnType) ?? Find(type);
+        return implicitOperator != null;
+
+        MethodBase? Find(Type searchType)
+        {
+            return searchType.GetMethods(BindingFlags.Public | BindingFlags.Static)
+                .FirstOrDefault(m =>
+                {
+                    if (m.Name != methodName || m.ReturnType != type)
+                    {
+                        return false;
+                    }
+
+                    var parameters = m.GetParameters();
+                    return parameters.Length == 1 && parameters[0].ParameterType == returnType;
+                });
+        }
+    }
 }