Merge pull request #190 from servicetitan/upstream/MakeGenericMethod

Memoize MakeGenericMethod(), MakeGenericType() methods (#50)

Author: alex-kulakov

Extensions/Xtensive.Orm.BulkOperations/Internals/ExpressionExtensions.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2019-2020 Xtensive LLC.
+// Copyright (C) 2019-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
@@ -29,7 +29,7 @@ public static bool IsContainsQuery(this Expression expression)
     internal static object Invoke(this Expression expression)
     {
       return FastExpression.Lambda(
-        WellKnownMembers.FuncOfTResultType.MakeGenericType(expression.Type), expression).Compile().DynamicInvoke();
+        WellKnownMembers.FuncOfTResultType.CachedMakeGenericType(expression.Type), expression).Compile().DynamicInvoke();
     }
 
     internal static Expression Visit<T>(this Expression exp, Func<T, Expression> visitor) where T : Expression

Extensions/Xtensive.Orm.BulkOperations/Internals/Operation.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2019-2021 Xtensive LLC.
+// Copyright (C) 2019-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
@@ -11,6 +11,7 @@
 using Xtensive.Orm.Linq;
 using Xtensive.Orm.Providers;
 using Xtensive.Orm.Services;
+using Xtensive.Reflection;
 using Xtensive.Sql;
 using Xtensive.Sql.Dml;
 using QueryParameterBinding = Xtensive.Orm.Services.QueryParameterBinding;
@@ -68,7 +69,7 @@ protected void EnsureTransactionIsStarted()
 
     public QueryTranslationResult GetRequest(Type type, IQueryable query)
     {
-      var translateQueryMethod = WellKnownMembers.TranslateQueryMethod.MakeGenericMethod(type);
+      var translateQueryMethod = WellKnownMembers.TranslateQueryMethod.CachedMakeGenericMethod(type);
       return (QueryTranslationResult) translateQueryMethod.Invoke(QueryBuilder, new object[] {query});
     }
 

Extensions/Xtensive.Orm.BulkOperations/Internals/QueryOperation.cs

@@ -9,6 +9,7 @@
 using Xtensive.Core;
 using Xtensive.Orm.Linq;
 using Xtensive.Orm.Model;
+using Xtensive.Reflection;
 using Xtensive.Sql;
 using Xtensive.Sql.Dml;
 
@@ -35,7 +36,7 @@ protected override int ExecuteInternal()
               ex.Arguments.Count == 2) {
             var localCollection = ex.Arguments[0];//IEnumerable<T>
             var valueToCheck = ex.Arguments[1];
-            var genericInMethod = WellKnownMembers.InMethod.MakeGenericMethod(new[] { valueToCheck.Type });
+            var genericInMethod = WellKnownMembers.InMethod.CachedMakeGenericMethod(valueToCheck.Type);
             ex = Expression.Call(genericInMethod, valueToCheck, Expression.Constant(IncludeAlgorithm.ComplexCondition), localCollection);
             methodInfo = ex.Method;
           }

Extensions/Xtensive.Orm.BulkOperations/Internals/SetOperation.cs

@@ -12,6 +12,7 @@
 using Xtensive.Sql.Dml;
 using Xtensive.Core;
 using Xtensive.Linq;
+using Xtensive.Reflection;
 
 namespace Xtensive.Orm.BulkOperations
 {
@@ -205,7 +206,7 @@ private void AddEntityValue(AddValueContext addContext)
             ParameterExpression p = Expression.Parameter(info.UnderlyingType);
             LambdaExpression lambda =
               FastExpression.Lambda(
-                WellKnownMembers.FuncOfTArgTResultType.MakeGenericType(info.UnderlyingType, field.ValueType),
+                WellKnownMembers.FuncOfTArgTResultType.CachedMakeGenericType(info.UnderlyingType, field.ValueType),
                 Expression.MakeMemberAccess(p, field.UnderlyingProperty),
                 p);
             IQueryable q =
@@ -244,7 +245,7 @@ public void AddValues()
           Descriptor = descriptor,
           Lambda =
             FastExpression.Lambda(
-              WellKnownMembers.FuncOfTArgTResultType.MakeGenericType(typeof (T), descriptor.Expression.Type),
+              WellKnownMembers.FuncOfTArgTResultType.CachedMakeGenericType(typeof (T), descriptor.Expression.Type),
               descriptor.Expression,
               descriptor.Parameter),
           Statement = Statement

Orm/Xtensive.Orm/Linq/ExpressionExtensions.cs

@@ -79,7 +79,7 @@ static ExpressionExtensions()
     {
       var tupleGenericAccessor = WellKnownOrmTypes.Tuple.GetMethods()
         .Single(mi => mi.Name == nameof(Tuple.GetValueOrDefault) && mi.IsGenericMethod);
-      TupleValueAccessorFactory = type => tupleGenericAccessor.MakeGenericMethod(type);
+      TupleValueAccessorFactory = type => tupleGenericAccessor.CachedMakeGenericMethod(type);
     }
   }
 }

Orm/Xtensive.Orm/Linq/Internals/LambdaExpressionFactory.cs

@@ -74,14 +74,14 @@ public LambdaExpression CreateLambda(Expression body, ParameterExpression[] para
     internal Factory CreateFactorySlow(Type delegateType)
     {
       var factory = (SlowFactory) Delegate.CreateDelegate(
-        SlowFactoryType, slowFactoryMethod.MakeGenericMethod(delegateType));
+        SlowFactoryType, slowFactoryMethod.CachedMakeGenericMethod(delegateType));
 
       return (body, parameters) => factory.Invoke(body, parameters);
     }
 
     internal static Factory CreateFactoryFast(Type delegateType)
     {
-      var method = WellKnownTypes.ExpressionOfT.MakeGenericType(delegateType).GetMethod(
+      var method = WellKnownTypes.ExpressionOfT.CachedMakeGenericType(delegateType).GetMethod(
         "Create", BindingFlags.Static | BindingFlags.NonPublic, null, internalFactorySignature, null);
 
       if (method == null) {

Orm/Xtensive.Orm/Modelling/PropertyAccessor.cs

@@ -175,7 +175,7 @@ private void Initialize()
         compareCaseInsensitive = tProperty == WellKnownTypes.String && pa.CaseInsensitiveComparison;
       }
       InnerInitializeMethodDefinition
-        .MakeGenericMethod(new[] {tType, tProperty})
+        .CachedMakeGenericMethod(tType, tProperty)
         .Invoke(this, null);
     }
 

Orm/Xtensive.Orm/Orm/Building/Builders/KeyGeneratorFactory.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2020 Xtensive LLC.
+// Copyright (C) 2012-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Denis Krjuchkov
@@ -31,22 +31,28 @@ internal static class KeyGeneratorFactory
       .Concat(new[] { WellKnownTypes.Guid, WellKnownTypes.String })
       .ToArray();
 
+    private static readonly Type
+      StorageSequentalGeneratorType = typeof(StorageSequentalGenerator<>),
+      TemporarySequentalGeneratorType = typeof(TemporarySequentalGenerator<>),
+      GuidGeneratorType = typeof(GuidGenerator),
+      StringGeneratorType = typeof(StringGenerator);
+
     public static bool IsSupported(Type valueType) => SupportedTypes.Contains(valueType);
 
     public static bool IsSequenceBacked(Type valueType) => SupportedNumericTypes.Contains(valueType);
 
     private static Type GetGeneratorType(Type valueType)
     {
       if (IsSequenceBacked(valueType)) {
-        return typeof(StorageSequentalGenerator<>).MakeGenericType(valueType);
+        return StorageSequentalGeneratorType.CachedMakeGenericType(valueType);
       }
 
       if (valueType == WellKnownTypes.Guid) {
-        return typeof(GuidGenerator);
+        return GuidGeneratorType;
       }
 
       if (valueType == WellKnownTypes.String) {
-        return typeof(StringGenerator);
+        return StringGeneratorType;
       }
 
       throw TypeNotSupported(valueType);
@@ -55,15 +61,15 @@ private static Type GetGeneratorType(Type valueType)
     private static Type GetTemporaryGeneratorType(Type valueType)
     {
       if (IsSequenceBacked(valueType)) {
-        return typeof(TemporarySequentalGenerator<>).MakeGenericType(valueType);
+        return TemporarySequentalGeneratorType.CachedMakeGenericType(valueType);
       }
 
       if (valueType == WellKnownTypes.Guid) {
-        return typeof(GuidGenerator);
+        return GuidGeneratorType;
       }
 
       if (valueType == WellKnownTypes.String) {
-        return typeof(StringGenerator);
+        return StringGeneratorType;
       }
 
       throw TypeNotSupported(valueType);

Orm/Xtensive.Orm/Orm/Building/Builders/ModelBuilder.cs

@@ -5,6 +5,7 @@
 // Created:    2007.09.26
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -26,7 +27,33 @@ internal sealed class ModelBuilder
   {
     private const string GeneratedTypeNameFormat = "{0}.EntitySetItems.{1}";
 
-    private static ThreadSafeDictionary<string, Type> GeneratedTypes = ThreadSafeDictionary<string, Type>.Create(new object());
+    private readonly struct TypeKey : IEquatable<TypeKey>
+    {
+      public readonly string Name;
+      public readonly Type OwnerType;
+      public readonly Type TargetType;
+
+      public bool Equals(TypeKey other) => string.Equals(Name, other.Name);
+
+      public override bool Equals(object obj) => obj is TypeKey other && Equals(other);
+
+      public override int GetHashCode() => (Name ?? string.Empty).GetHashCode();
+
+      public TypeKey(string name, Type ownerType, Type targetType)
+      {
+        Name = name;
+        OwnerType = ownerType;
+        TargetType = targetType;
+      }
+    }
+
+    private static readonly ConcurrentDictionary<TypeKey, Lazy<Type>> GeneratedTypes = new ConcurrentDictionary<TypeKey, Lazy<Type>>();
+
+    private static readonly Func<TypeKey, Lazy<Type>> AuxiliaryTypeFactory = typeKey =>
+      new Lazy<Type>(() => {
+        var baseType = WellKnownOrmTypes.EntitySetItemOfT1T2.CachedMakeGenericType(typeKey.OwnerType, typeKey.TargetType);
+        return TypeHelper.CreateInheritedDummyType(typeKey.Name, baseType, true);
+      });
 
     private readonly BuildingContext context;
     private readonly TypeBuilder typeBuilder;
@@ -403,20 +430,14 @@ private void BuildAuxiliaryTypes(IEnumerable<AssociationInfo> associations)
 
     private Type GenerateAuxiliaryType(AssociationInfo association)
     {
-      var masterType = association.OwnerType.UnderlyingType;
-      var slaveType = association.TargetType.UnderlyingType;
-      var baseType = WellKnownOrmTypes.EntitySetItemOfT1T2.MakeGenericType(masterType, slaveType);
+      var ownerType = association.OwnerType.UnderlyingType;
+      var targetType = association.TargetType.UnderlyingType;
 
       var typeName = string.Format(GeneratedTypeNameFormat,
-        masterType.Namespace,
+        ownerType.Namespace,
         context.NameBuilder.BuildAssociationName(association));
 
-      var result = GeneratedTypes.GetValue(typeName,
-        (_typeName, _baseType) =>
-          TypeHelper.CreateInheritedDummyType(_typeName, _baseType, true),
-        baseType);
-
-      return result;
+      return GeneratedTypes.GetOrAdd(new TypeKey(typeName, ownerType, targetType), AuxiliaryTypeFactory).Value;
     }
 
     private void FindAndMarkInboundAndOutboundTypes(BuildingContext context)

Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs

@@ -113,7 +113,7 @@ private Expression BuildFieldAccess(FieldInfo field, bool addNullability)
       var valueType = addNullability ? field.ValueType.ToNullable() : field.ValueType;
       usedFields.Add(field);
       return Expression.Call(Parameter,
-        WellKnownMembers.Tuple.GenericAccessor.MakeGenericMethod(valueType),
+        WellKnownMembers.Tuple.GenericAccessor.CachedMakeGenericMethod(valueType),
         Expression.Constant(fieldIndex));
     }