Optimize TryGetArgumentDirectionAndType

Author: marius-bughiu

src/UiPath.Workflow.Runtime/ActivityUtilities.cs

@@ -10,6 +10,7 @@ namespace System.Activities;
 using Expressions;
 using Internals;
 using Runtime;
+using System.Collections.Concurrent;
 using Validation;
 
 internal static class ActivityUtilities
@@ -47,6 +48,8 @@ internal static class ActivityUtilities
     private static readonly Type outArgumentOfObjectType = typeof(OutArgument<object>);
     private static readonly Type inOutArgumentOfObjectType = typeof(InOutArgument<object>);
     private static PropertyChangedEventArgs propertyChangedEventArgs;
+    
+    private static readonly ConcurrentDictionary<Type, ArgumentTypeInfo> argumentTypeCache = new();
 
     // Can't delay create this one because we use object.ReferenceEquals on it in WorkflowInstance
     private static readonly ReadOnlyDictionary<string, object> emptyParameters = new(new Dictionary<string, object>(0));
@@ -97,55 +100,82 @@ public static bool IsInScope(ActivityInstance potentialChild, ActivityInstance s
 
     public static bool IsCompletedState(ActivityInstanceState state) => state != ActivityInstanceState.Executing;
 
+    private readonly struct ArgumentTypeInfo
+    {
+        public readonly bool IsArgument;
+        public readonly ArgumentDirection Direction;
+        public readonly Type ArgumentType;
+
+        public ArgumentTypeInfo(bool isArgument, ArgumentDirection direction, Type argumentType)
+        {
+            IsArgument = isArgument;
+            Direction = direction;
+            ArgumentType = argumentType;
+        }
+    }
+
     public static bool TryGetArgumentDirectionAndType(Type propertyType, out ArgumentDirection direction, out Type argumentType)
     {
-        direction = ArgumentDirection.In; // default to In
-        argumentType = TypeHelper.ObjectType;  // default to object
+        if (argumentTypeCache.TryGetValue(propertyType, out ArgumentTypeInfo info))
+        {
+            direction = info.Direction;
+            argumentType = info.ArgumentType;
+            return info.IsArgument;
+        }
+
+        bool isArgument = false;
+        direction = ArgumentDirection.In;
+        argumentType = TypeHelper.ObjectType;
 
         if (propertyType.IsGenericType)
         {
-            argumentType = propertyType.GetGenericArguments()[0];
-
             Type genericType = propertyType.GetGenericTypeDefinition();
 
             if (genericType == inArgumentGenericType)
             {
-                return true;
+                direction = ArgumentDirection.In;
+                argumentType = propertyType.GetGenericArguments()[0];
+                isArgument = true;
             }
-
-            if (genericType == outArgumentGenericType)
+            else if (genericType == outArgumentGenericType)
             {
                 direction = ArgumentDirection.Out;
-                return true;
+                argumentType = propertyType.GetGenericArguments()[0];
+                isArgument = true;
             }
-
-            if (genericType == inOutArgumentGenericType)
+            else if (genericType == inOutArgumentGenericType)
             {
                 direction = ArgumentDirection.InOut;
-                return true;
+                argumentType = propertyType.GetGenericArguments()[0];
+                isArgument = true;
             }
         }
         else
         {
             if (propertyType == inArgumentType)
             {
-                return true;
+                direction = ArgumentDirection.In;
+                argumentType = TypeHelper.ObjectType;
+                isArgument = true;
             }
-
-            if (propertyType == outArgumentType)
+            else if (propertyType == outArgumentType)
             {
                 direction = ArgumentDirection.Out;
-                return true;
+                argumentType = TypeHelper.ObjectType;
+                isArgument = true;
             }
-
-            if (propertyType == inOutArgumentType)
+            else if (propertyType == inOutArgumentType)
             {
                 direction = ArgumentDirection.InOut;
-                return true;
+                argumentType = TypeHelper.ObjectType;
+                isArgument = true;
             }
         }
 
-        return false;
+        var newInfo = new ArgumentTypeInfo(isArgument, direction, argumentType);
+        argumentTypeCache.TryAdd(propertyType, newInfo);
+
+        return isArgument;
     }
 
     public static bool IsArgumentType(Type propertyType) => TypeHelper.AreTypesCompatible(propertyType, argumentType);

src/UiPath.Workflow.Runtime/AssemblyInfo.cs

@@ -28,4 +28,5 @@
 [assembly: InternalsVisibleTo("UiPath.Workflow")]
 [assembly: InternalsVisibleTo("TestCases.Workflows")]
 [assembly: InternalsVisibleTo("TestCases.Runtime")]
+[assembly: InternalsVisibleTo("CoreWf.Benchmarks")]
 [assembly: InternalsVisibleTo("Perf.AssemblyReference.Benchmarks")]