PERF-392: Avoid closure allocation in .GetCompiler() (#419)

SergeiPavlov · web-flow · commit 77e8b0a78511 · 2025-11-03T17:58:22.000-08:00
* PERF-392: Avoid closure allocation in `.GetCompiler()`

* allow null compiler

* Fix NonPublicGetterTest

* Remove public
diff --git a/Orm/Xtensive.Orm.Tests/Linq/MemberCompilerProviderTest.cs b/Orm/Xtensive.Orm.Tests/Linq/MemberCompilerProviderTest.cs
@@ -20,7 +20,7 @@ public partial class MemberCompilerProviderTest
   {
     private readonly string[] dummy = new string[10];
     
-    private static Func<string, string[],string> GetCompilerForMethod(
+    private static IMemberCompilerProvider<string>.BoundCompiler GetCompilerForMethod(
       IMemberCompilerProvider<string> provider, Type source, string methodName)
     {
       if (source.IsGenericTypeDefinition)
@@ -31,23 +31,23 @@ private static Func<string, string[],string> GetCompilerForMethod(
       if (mi.IsGenericMethodDefinition)
         mi = mi.MakeGenericMethod(typeof(object));
       var result = provider.GetCompiler(mi);
-      Assert.IsNotNull(result);
+      Assert.IsFalse(result.IsNull);
       return result;
     }
 
-    private static Func<string, string[], string> GetCompilerForCtor(
+    private static IMemberCompilerProvider<string>.BoundCompiler GetCompilerForCtor(
       IMemberCompilerProvider<string> provider, Type source)
     {
       if (source.IsGenericTypeDefinition)
         source = source.MakeGenericType(typeof(object));
 
       var ci = source.GetConstructors().First();
       var result = provider.GetCompiler(ci);
-      Assert.IsNotNull(result);
+      Assert.IsFalse(result.IsNull);
       return result;
     }
 
-    private static Func<string, string[], string> GetCompilerForField(
+    private static IMemberCompilerProvider<string>.BoundCompiler GetCompilerForField(
       IMemberCompilerProvider<string> provider, Type source, string fieldName)
     {
       if (source.IsGenericTypeDefinition)
@@ -56,7 +56,7 @@ private static Func<string, string[], string> GetCompilerForField(
       var fi = source.GetField(fieldName);
       Assert.IsNotNull(fi);
       var result = provider.GetCompiler(fi);
-      Assert.IsNotNull(result);
+      Assert.IsFalse(result.IsNull);
       return result;
     }
 
@@ -71,7 +71,7 @@ public void MethodsTest()
           foreach (string s2 in new[]{"Generic", "NonGeneric"}) {
             string method = s1 + s2 + "Method";
             var d = GetCompilerForMethod(provider, t, method);
-            Assert.AreEqual(t.Name + "." + method, d(null, dummy));
+            Assert.AreEqual(t.Name + "." + method, d.Invoke(null, dummy));
           }
     }
 
@@ -86,7 +86,7 @@ public void PropertiesTest()
           foreach (string s2 in new[] { "InstanceProperty", "StaticProperty", "Item" }) {
             string method = s1 + s2;
             var d = GetCompilerForMethod(provider, t, method);
-            Assert.AreEqual(t.Name + "." + method, d(null, dummy));
+            Assert.AreEqual(t.Name + "." + method, d.Invoke(null, dummy));
           }
     }
 
@@ -99,7 +99,7 @@ public void FieldsTest()
       foreach (var t in new[]{typeof(NonGenericTarget), typeof(GenericTarget<>)})
         foreach (string s in new[] {"InstanceField", "StaticField"}) {
           var d = GetCompilerForField(provider, t, s);
-          Assert.AreEqual(t.Name + "." + s, d(null, dummy));
+          Assert.AreEqual(t.Name + "." + s, d.Invoke(null, dummy));
         }
     }
 
@@ -110,7 +110,7 @@ public void CtorsTest()
       provider.RegisterCompilers(typeof(CtorCompiler));
       foreach (var t in new[]{typeof(NonGenericTarget), typeof(GenericTarget<>)}) {
         var d = GetCompilerForCtor(provider, t);
-        Assert.AreEqual(t.Name + Reflection.WellKnown.CtorName, d(null, dummy));
+        Assert.AreEqual(t.Name + Reflection.WellKnown.CtorName, d.Invoke(null, dummy));
       }
     }
 
@@ -128,8 +128,8 @@ public void GenericFindTest()
         .MakeGenericMethod(typeof(string));
 
       var d = provider.GetCompiler(mi);
-      Assert.IsNotNull(d);
-      Assert.AreEqual("OK", d(null, dummy));
+      Assert.IsFalse(d.IsNull);
+      Assert.AreEqual("OK", d.Invoke(null, dummy));
     }
 
     [Test]
@@ -160,7 +160,7 @@ public void ConflictKeepOldTest()
       provider.RegisterCompilers(typeof(ConflictCompiler1));
       provider.RegisterCompilers(typeof(ConflictCompiler2), ConflictHandlingMethod.KeepOld);
       var d = GetCompilerForMethod(provider, typeof(ConflictTarget), "ConflictMethod");
-      Assert.AreEqual("Compiler1", d(null, dummy));
+      Assert.AreEqual("Compiler1", d.Invoke(null, dummy));
     }
 
     [Test]
@@ -170,7 +170,7 @@ public void ConflictOverwriteTest()
       provider.RegisterCompilers(typeof(ConflictCompiler1));
       provider.RegisterCompilers(typeof(ConflictCompiler2), ConflictHandlingMethod.Overwrite);
       var d = GetCompilerForMethod(provider, typeof(ConflictTarget), "ConflictMethod");
-      Assert.AreEqual("Compiler2", d(null, dummy));
+      Assert.AreEqual("Compiler2", d.Invoke(null, dummy));
     }
 
     [Test]
@@ -189,7 +189,7 @@ public void NonPublicGetterTest()
         .GetProperty("InternalProperty", BindingFlags.Instance | BindingFlags.NonPublic);
       Assert.IsNotNull(property);
       var result = provider.GetCompiler(property);
-      Assert.IsNull(result);
+      Assert.IsTrue(result.IsNull);
     }
 
     [Test]
diff --git a/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/Interfaces/IMemberCompilerProvider{T}.cs b/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/Interfaces/IMemberCompilerProvider{T}.cs
@@ -4,8 +4,6 @@
 // Created by: Denis Krjuchkov
 // Created:    2009.02.09
 
-using System;
-using System.Collections.Generic;
 using System.Reflection;
 
 namespace Xtensive.Orm.Linq.MemberCompilation
@@ -36,12 +34,19 @@ public interface IMemberCompilerProvider<T> : IMemberCompilerProvider
     /// <param name="conflictHandlingMethod">Conflict handling method.</param>
     void RegisterCompilers(IEnumerable<KeyValuePair<MemberInfo, Func<MemberInfo, T, T[], T>>> compilerDefinitions, ConflictHandlingMethod conflictHandlingMethod);
 
+    readonly struct BoundCompiler(Func<MemberInfo, T, T[], T> compiler, MemberInfo memberInfo)
+    {
+      public bool IsNull => compiler == null;
+
+      public T Invoke(T arg2, T[] arg3) => compiler(memberInfo, arg2, arg3);
+    }
+
     /// <summary>
     /// Finds compiler for specified <see cref="MemberInfo"/>.
     /// </summary>
     /// <param name="target"><see cref="MemberInfo"/> to search compiler for.</param>
     /// <returns>compiler associated with <see cref="MethodInfo"/>
     /// or <see langword="null"/> if compiler is not found.</returns>
-    Func<T, T[], T> GetCompiler(MemberInfo target);
+    BoundCompiler GetCompiler(MemberInfo target);
   }
 }
diff --git a/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/MemberCompilerProvider.cs b/Orm/Xtensive.Orm/Orm/Linq/MemberCompilation/MemberCompilerProvider.cs
@@ -4,9 +4,7 @@
 // Created by: Denis Krjuchkov
 // Created:    2009.02.09
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Collections.Frozen;
 using System.Reflection;
 using Xtensive.Core;
 using Xtensive.Reflection;
@@ -36,24 +34,25 @@ public CompilerKey(MemberInfo memberInfo)
       }
     }
 
-    private readonly Dictionary<CompilerKey, Delegate> compilers
-      = new Dictionary<CompilerKey, Delegate>();
+    private IDictionary<CompilerKey, Delegate> compilers = new Dictionary<CompilerKey, Delegate>();
 
     public Type ExpressionType => typeof(T);
 
-    public Delegate GetUntypedCompiler(MemberInfo target)
+    public override void Lock(bool recursive)
     {
-      ArgumentNullException.ThrowIfNull(target);
-
-      return compilers.GetValueOrDefault(GetCompilerKey(target));
+      base.Lock(recursive);
+      compilers = compilers.ToFrozenDictionary();
     }
 
-    public Func<T, T[], T> GetCompiler(MemberInfo target)
+    public Delegate GetUntypedCompiler(MemberInfo target)
     {
-      var compiler = (Func<MemberInfo, T, T[], T>) GetUntypedCompiler(target);
-      return compiler.Bind(target);
+      ArgumentNullException.ThrowIfNull(target);
+      return compilers.TryGetValue(GetCompilerKey(target), out var v) ? v : null;
     }
 
+    public IMemberCompilerProvider<T>.BoundCompiler GetCompiler(MemberInfo target) =>
+      new((Func<MemberInfo, T, T[], T>) GetUntypedCompiler(target), target);
+
     public void RegisterCompilers(Type compilerContainer)
     {
       RegisterCompilers(compilerContainer, ConflictHandlingMethod.Default);
diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs
@@ -361,18 +361,18 @@ protected override Expression VisitMember(MemberExpression ma)
       // Reflected type doesn't have custom compiler defined, so falling back to base class compiler
       var declaringType = memberInfo.DeclaringType;
       var reflectedType = memberInfo.ReflectedType;
-      if (customCompiler == null && declaringType != reflectedType && declaringType.IsAssignableFrom(reflectedType)) {
+      if (customCompiler.IsNull && declaringType != reflectedType && declaringType.IsAssignableFrom(reflectedType)) {
         var root = declaringType;
         var current = reflectedType;
-        while (current != root && customCompiler == null) {
+        while (current != root && customCompiler.IsNull) {
           current = current.BaseType;
           var member = current.GetProperty(memberInfo.Name, BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
           customCompiler = context.CustomCompilerProvider.GetCompiler(member);
         }
       }
 
-      if (customCompiler != null) {
-        var expression = customCompiler.Invoke(sourceExpression, Array.Empty<Expression>());
+      if (!customCompiler.IsNull) {
+        var expression = customCompiler.Invoke(sourceExpression, []);
         if (expression == null) {
           if (reflectedType.IsInterface)
             return Visit(BuildInterfaceExpression(ma));
@@ -435,7 +435,7 @@ protected override Expression VisitMethodCall(MethodCallExpression mc)
       using (CreateScope(new TranslatorState(State) { IsTailMethod = mc == context.Query && mc.IsQuery() })) {
         var method = mc.Method;
         var customCompiler = context.CustomCompilerProvider.GetCompiler(method);
-        if (customCompiler != null) {
+        if (!customCompiler.IsNull) {
           return Visit(customCompiler.Invoke(mc.Object, mc.Arguments.ToArray()));
         }
 
@@ -1841,7 +1841,7 @@ private Expression BuildExpression(MemberExpression ma, IEnumerable<PropertyInfo
       Expression current = Expression.Constant(defaultValue, propertyType);
       foreach (var field in fields) {
         var compiler = context.CustomCompilerProvider.GetCompiler(field);
-        if (compiler == null)
+        if (compiler.IsNull)
           continue;
         var expression = compiler.Invoke(Expression.TypeAs(ma.Expression, field.ReflectedType), null);
         current = Expression.Condition(Expression.TypeIs(ma.Expression, field.ReflectedType), expression, current);
diff --git a/Orm/Xtensive.Orm/Orm/Providers/Expressions/ExpressionProcessor.Helpers.cs b/Orm/Xtensive.Orm/Orm/Providers/Expressions/ExpressionProcessor.Helpers.cs
@@ -201,8 +201,10 @@ private static SqlExpression OracleBlobCompare(SqlExpression left, SqlExpression
 
     private SqlExpression CompileMember(MemberInfo member, SqlExpression instance, params SqlExpression[] arguments)
     {
-      var memberCompiler = memberCompilerProvider.GetCompiler(member)
-        ?? throw new NotSupportedException(string.Format(Strings.ExMemberXIsNotSupported, member.GetFullName(true)));
+      var memberCompiler = memberCompilerProvider.GetCompiler(member);
+      if (memberCompiler.IsNull) {
+        throw new NotSupportedException(string.Format(Strings.ExMemberXIsNotSupported, member.GetFullName(true)));
+      }
       return memberCompiler.Invoke(instance, arguments);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ public partial class MemberCompilerProviderTest`
`20`	`20`	`{`
`21`	`21`	`private readonly string[] dummy = new string[10];`
`22`	`22`
`23`		`- private static Func<string, string[],string> GetCompilerForMethod(`
	`23`	`+ private static IMemberCompilerProvider<string>.BoundCompiler GetCompilerForMethod(`
`24`	`24`	`IMemberCompilerProvider<string> provider, Type source, string methodName)`
`25`	`25`	`{`
`26`	`26`	`if (source.IsGenericTypeDefinition)`
`@@ -31,23 +31,23 @@ private static Func<string, string[],string> GetCompilerForMethod(`
`31`	`31`	`if (mi.IsGenericMethodDefinition)`
`32`	`32`	`mi = mi.MakeGenericMethod(typeof(object));`
`33`	`33`	`var result = provider.GetCompiler(mi);`
`34`		`- Assert.IsNotNull(result);`
	`34`	`+ Assert.IsFalse(result.IsNull);`
`35`	`35`	`return result;`
`36`	`36`	`}`
`37`	`37`
`38`		`- private static Func<string, string[], string> GetCompilerForCtor(`
	`38`	`+ private static IMemberCompilerProvider<string>.BoundCompiler GetCompilerForCtor(`
`39`	`39`	`IMemberCompilerProvider<string> provider, Type source)`
`40`	`40`	`{`
`41`	`41`	`if (source.IsGenericTypeDefinition)`
`42`	`42`	`source = source.MakeGenericType(typeof(object));`
`43`	`43`
`44`	`44`	`var ci = source.GetConstructors().First();`
`45`	`45`	`var result = provider.GetCompiler(ci);`
`46`		`- Assert.IsNotNull(result);`
	`46`	`+ Assert.IsFalse(result.IsNull);`
`47`	`47`	`return result;`
`48`	`48`	`}`
`49`	`49`
`50`		`- private static Func<string, string[], string> GetCompilerForField(`
	`50`	`+ private static IMemberCompilerProvider<string>.BoundCompiler GetCompilerForField(`
`51`	`51`	`IMemberCompilerProvider<string> provider, Type source, string fieldName)`
`52`	`52`	`{`
`53`	`53`	`if (source.IsGenericTypeDefinition)`
`@@ -56,7 +56,7 @@ private static Func<string, string[], string> GetCompilerForField(`
`56`	`56`	`var fi = source.GetField(fieldName);`
`57`	`57`	`Assert.IsNotNull(fi);`
`58`	`58`	`var result = provider.GetCompiler(fi);`
`59`		`- Assert.IsNotNull(result);`
	`59`	`+ Assert.IsFalse(result.IsNull);`
`60`	`60`	`return result;`
`61`	`61`	`}`
`62`	`62`
`@@ -71,7 +71,7 @@ public void MethodsTest()`
`71`	`71`	`foreach (string s2 in new[]{"Generic", "NonGeneric"}) {`
`72`	`72`	`string method = s1 + s2 + "Method";`
`73`	`73`	`var d = GetCompilerForMethod(provider, t, method);`
`74`		`- Assert.AreEqual(t.Name + "." + method, d(null, dummy));`
	`74`	`+ Assert.AreEqual(t.Name + "." + method, d.Invoke(null, dummy));`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`@@ -86,7 +86,7 @@ public void PropertiesTest()`
`86`	`86`	`foreach (string s2 in new[] { "InstanceProperty", "StaticProperty", "Item" }) {`
`87`	`87`	`string method = s1 + s2;`
`88`	`88`	`var d = GetCompilerForMethod(provider, t, method);`
`89`		`- Assert.AreEqual(t.Name + "." + method, d(null, dummy));`
	`89`	`+ Assert.AreEqual(t.Name + "." + method, d.Invoke(null, dummy));`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`@@ -99,7 +99,7 @@ public void FieldsTest()`
`99`	`99`	`foreach (var t in new[]{typeof(NonGenericTarget), typeof(GenericTarget<>)})`
`100`	`100`	`foreach (string s in new[] {"InstanceField", "StaticField"}) {`
`101`	`101`	`var d = GetCompilerForField(provider, t, s);`
`102`		`- Assert.AreEqual(t.Name + "." + s, d(null, dummy));`
	`102`	`+ Assert.AreEqual(t.Name + "." + s, d.Invoke(null, dummy));`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`@@ -110,7 +110,7 @@ public void CtorsTest()`
`110`	`110`	`provider.RegisterCompilers(typeof(CtorCompiler));`
`111`	`111`	`foreach (var t in new[]{typeof(NonGenericTarget), typeof(GenericTarget<>)}) {`
`112`	`112`	`var d = GetCompilerForCtor(provider, t);`
`113`		`- Assert.AreEqual(t.Name + Reflection.WellKnown.CtorName, d(null, dummy));`
	`113`	`+ Assert.AreEqual(t.Name + Reflection.WellKnown.CtorName, d.Invoke(null, dummy));`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`@@ -128,8 +128,8 @@ public void GenericFindTest()`
`128`	`128`	`.MakeGenericMethod(typeof(string));`
`129`	`129`
`130`	`130`	`var d = provider.GetCompiler(mi);`
`131`		`- Assert.IsNotNull(d);`
`132`		`- Assert.AreEqual("OK", d(null, dummy));`
	`131`	`+ Assert.IsFalse(d.IsNull);`
	`132`	`+ Assert.AreEqual("OK", d.Invoke(null, dummy));`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`[Test]`
`@@ -160,7 +160,7 @@ public void ConflictKeepOldTest()`
`160`	`160`	`provider.RegisterCompilers(typeof(ConflictCompiler1));`
`161`	`161`	`provider.RegisterCompilers(typeof(ConflictCompiler2), ConflictHandlingMethod.KeepOld);`
`162`	`162`	`var d = GetCompilerForMethod(provider, typeof(ConflictTarget), "ConflictMethod");`
`163`		`- Assert.AreEqual("Compiler1", d(null, dummy));`
	`163`	`+ Assert.AreEqual("Compiler1", d.Invoke(null, dummy));`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`[Test]`
`@@ -170,7 +170,7 @@ public void ConflictOverwriteTest()`
`170`	`170`	`provider.RegisterCompilers(typeof(ConflictCompiler1));`
`171`	`171`	`provider.RegisterCompilers(typeof(ConflictCompiler2), ConflictHandlingMethod.Overwrite);`
`172`	`172`	`var d = GetCompilerForMethod(provider, typeof(ConflictTarget), "ConflictMethod");`
`173`		`- Assert.AreEqual("Compiler2", d(null, dummy));`
	`173`	`+ Assert.AreEqual("Compiler2", d.Invoke(null, dummy));`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`[Test]`
`@@ -189,7 +189,7 @@ public void NonPublicGetterTest()`
`189`	`189`	`.GetProperty("InternalProperty", BindingFlags.Instance \| BindingFlags.NonPublic);`
`190`	`190`	`Assert.IsNotNull(property);`
`191`	`191`	`var result = provider.GetCompiler(property);`
`192`		`- Assert.IsNull(result);`
	`192`	`+ Assert.IsTrue(result.IsNull);`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,7 @@`
`4`	`4`	`// Created by: Denis Krjuchkov`
`5`	`5`	`// Created: 2009.02.09`
`6`	`6`
`7`		`-using System;`
`8`		`-using System.Collections.Generic;`
`9`		`-using System.Linq;`
	`7`	`+using System.Collections.Frozen;`
`10`	`8`	`using System.Reflection;`
`11`	`9`	`using Xtensive.Core;`
`12`	`10`	`using Xtensive.Reflection;`
`@@ -36,24 +34,25 @@ public CompilerKey(MemberInfo memberInfo)`
`36`	`34`	`}`
`37`	`35`	`}`
`38`	`36`
`39`		`- private readonly Dictionary<CompilerKey, Delegate> compilers`
`40`		`- = new Dictionary<CompilerKey, Delegate>();`
	`37`	`+ private IDictionary<CompilerKey, Delegate> compilers = new Dictionary<CompilerKey, Delegate>();`
`41`	`38`
`42`	`39`	`public Type ExpressionType => typeof(T);`
`43`	`40`
`44`		`- public Delegate GetUntypedCompiler(MemberInfo target)`
	`41`	`+ public override void Lock(bool recursive)`
`45`	`42`	`{`
`46`		`- ArgumentNullException.ThrowIfNull(target);`
`47`		`-`
`48`		`- return compilers.GetValueOrDefault(GetCompilerKey(target));`
	`43`	`+ base.Lock(recursive);`
	`44`	`+ compilers = compilers.ToFrozenDictionary();`
`49`	`45`	`}`
`50`	`46`
`51`		`- public Func<T, T[], T> GetCompiler(MemberInfo target)`
	`47`	`+ public Delegate GetUntypedCompiler(MemberInfo target)`
`52`	`48`	`{`
`53`		`- var compiler = (Func<MemberInfo, T, T[], T>) GetUntypedCompiler(target);`
`54`		`- return compiler.Bind(target);`
	`49`	`+ ArgumentNullException.ThrowIfNull(target);`
	`50`	`+ return compilers.TryGetValue(GetCompilerKey(target), out var v) ? v : null;`
`55`	`51`	`}`
`56`	`52`
	`53`	`+ public IMemberCompilerProvider<T>.BoundCompiler GetCompiler(MemberInfo target) =>`
	`54`	`+ new((Func<MemberInfo, T, T[], T>) GetUntypedCompiler(target), target);`
	`55`	`+`
`57`	`56`	`public void RegisterCompilers(Type compilerContainer)`
`58`	`57`	`{`
`59`	`58`	`RegisterCompilers(compilerContainer, ConflictHandlingMethod.Default);`
Original file line number	Diff line number	Diff line change
`@@ -201,8 +201,10 @@ private static SqlExpression OracleBlobCompare(SqlExpression left, SqlExpression`
`201`	`201`
`202`	`202`	`private SqlExpression CompileMember(MemberInfo member, SqlExpression instance, params SqlExpression[] arguments)`
`203`	`203`	`{`
`204`		`- var memberCompiler = memberCompilerProvider.GetCompiler(member)`
`205`		`- ?? throw new NotSupportedException(string.Format(Strings.ExMemberXIsNotSupported, member.GetFullName(true)));`
	`204`	`+ var memberCompiler = memberCompilerProvider.GetCompiler(member);`
	`205`	`+ if (memberCompiler.IsNull) {`
	`206`	`+ throw new NotSupportedException(string.Format(Strings.ExMemberXIsNotSupported, member.GetFullName(true)));`
	`207`	`+ }`
`206`	`208`	`return memberCompiler.Invoke(instance, arguments);`
`207`	`209`	`}`
`208`	`210`