Unity 2021.2.0a14 C# reference source code

Author: Unity Technologies

Editor/Mono/AssetDatabase/AssetDatabase.cs

@@ -19,53 +19,74 @@ public sealed partial class AssetDatabase
         public delegate void ImportPackageFailedCallback(string packageName, string errorMessage);
 
         // Delegate to be called when package import begins
-        public static event ImportPackageCallback importPackageStarted;
+        public static event ImportPackageCallback importPackageStarted
+        {
+            add => m_importPackageStartedEvent.Add(value);
+            remove => m_importPackageStartedEvent.Remove(value);
+        }
+        private static EventWithPerformanceTracker<ImportPackageCallback> m_importPackageStartedEvent = new EventWithPerformanceTracker<ImportPackageCallback>($"{nameof(AssetDatabase)}.{nameof(importPackageStarted)}");
 
         // Delegate to be called when package import completes
-        public static event ImportPackageCallback importPackageCompleted;
+        public static event ImportPackageCallback importPackageCompleted
+        {
+            add => m_importPackageCompletedEvent.Add(value);
+            remove => m_importPackageCompletedEvent.Remove(value);
+        }
+        private static EventWithPerformanceTracker<ImportPackageCallback> m_importPackageCompletedEvent = new EventWithPerformanceTracker<ImportPackageCallback>($"{nameof(AssetDatabase)}.{nameof(importPackageCompleted)}");
 
         // Called when package import completes, listing the selected items
         public static Action<string[]> onImportPackageItemsCompleted;
+        private static DelegateWithPerformanceTracker<Action<string[]>> m_onImportPackageItemsCompleted = new DelegateWithPerformanceTracker<Action<string[]>>($"{nameof(AssetDatabase)}.{nameof(onImportPackageItemsCompleted)}");
 
         // Delegate to be called when package import is cancelled
-        public static event ImportPackageCallback importPackageCancelled;
+        public static event ImportPackageCallback importPackageCancelled
+        {
+            add => m_importPackageCancelledEvent.Add(value);
+            remove => m_importPackageCancelledEvent.Remove(value);
+        }
+        private static EventWithPerformanceTracker<ImportPackageCallback> m_importPackageCancelledEvent = new EventWithPerformanceTracker<ImportPackageCallback>($"{nameof(AssetDatabase)}.{nameof(importPackageCancelled)}");
 
         // Delegate to be called when package import fails
-        public static event ImportPackageFailedCallback importPackageFailed;
+        public static event ImportPackageFailedCallback importPackageFailed
+        {
+            add => m_importPackageFailedEvent.Add(value);
+            remove => m_importPackageFailedEvent.Remove(value);
+        }
+        private static EventWithPerformanceTracker<ImportPackageFailedCallback> m_importPackageFailedEvent = new EventWithPerformanceTracker<ImportPackageFailedCallback>($"{nameof(AssetDatabase)}.{nameof(importPackageFailed)}");
 
         [RequiredByNativeCode]
         private static void Internal_CallImportPackageStarted(string packageName)
         {
-            if (importPackageStarted != null)
-                importPackageStarted(packageName);
+            foreach (var evt in m_importPackageStartedEvent)
+                evt(packageName);
         }
 
         [RequiredByNativeCode]
         private static void Internal_CallImportPackageCompleted(string packageName)
         {
-            if (importPackageCompleted != null)
-                importPackageCompleted(packageName);
+            foreach (var evt in m_importPackageCompletedEvent)
+                evt(packageName);
         }
 
         [RequiredByNativeCode]
         private static void Internal_CallOnImportPackageItemsCompleted(string[] items)
         {
-            if (onImportPackageItemsCompleted != null)
-                onImportPackageItemsCompleted(items);
+            foreach (var evt in m_onImportPackageItemsCompleted.UpdateAndInvoke(onImportPackageItemsCompleted))
+                evt(items);
         }
 
         [RequiredByNativeCode]
         private static void Internal_CallImportPackageCancelled(string packageName)
         {
-            if (importPackageCancelled != null)
-                importPackageCancelled(packageName);
+            foreach (var evt in m_importPackageCancelledEvent)
+                evt(packageName);
         }
 
         [RequiredByNativeCode]
         private static void Internal_CallImportPackageFailed(string packageName, string errorMessage)
         {
-            if (importPackageFailed != null)
-                importPackageFailed(packageName, errorMessage);
+            foreach (var evt in m_importPackageFailedEvent)
+                evt(packageName, errorMessage);
         }
 
         [RequiredByNativeCode]

Editor/Mono/AssetDatabase/AssetsModifiedProcessor.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using UnityEditor.Profiling;
 
 namespace UnityEditor.Experimental
 {
@@ -30,7 +31,11 @@ protected void ReportAssetChanged(string assetChanged)
 
         internal void Internal_OnAssetsModified(string[] changedAssets, string[] addedAssets, string[] deletedAssets, AssetMoveInfo[] movedAssets)
         {
-            OnAssetsModified(changedAssets, addedAssets, deletedAssets, movedAssets);
+            var type = GetType();
+            using (new EditorPerformanceMarker($"{type.Name}.{nameof(OnAssetsModified)}", type).Auto())
+            {
+                OnAssetsModified(changedAssets, addedAssets, deletedAssets, movedAssets);
+            }
         }
     }
 }

Editor/Mono/AssetModificationProcessor.cs

@@ -11,6 +11,7 @@
 using UnityEditorInternal.VersionControl;
 using System.Linq;
 using System.Reflection;
+using UnityEditor.Profiling;
 using UnityEngine.Scripting.APIUpdating;
 
 namespace UnityEditor
@@ -100,14 +101,16 @@ static void OnWillCreateAsset(string path)
         {
             foreach (var assetModificationProcessorClass in AssetModificationProcessors)
             {
-                MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillCreateAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "OnWillCreateAsset";
+                MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method != null)
                 {
                     object[] args = { path };
                     if (!CheckArguments(args, method))
                         continue;
 
-                    method.Invoke(null, args);
+                    using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto())
+                        method.Invoke(null, args);
                 }
             }
         }
@@ -120,12 +123,14 @@ static void FileModeChanged(string[] assets, FileMode mode)
             object[] args = { assets, mode };
             foreach (var type in AssetModificationProcessors)
             {
-                var method = type.GetMethod("FileModeChanged", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "FileModeChanged";
+                var method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method == null)
                     continue;
                 if (!CheckArgumentsAndReturnType(args, method, typeof(void)))
                     continue;
-                method.Invoke(null, args);
+                using (new EditorPerformanceMarker($"{type.Name}.{methodName}", type).Auto())
+                    method.Invoke(null, args);
             }
         }
 
@@ -151,14 +156,17 @@ static void OnWillSaveAssets(string[] assets, out string[] assetsThatShouldBeSav
 
             foreach (var assetModificationProcessorClass in AssetModificationProcessors)
             {
-                MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillSaveAssets", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "OnWillSaveAssets";
+                MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method != null)
                 {
                     object[] args = { assetsThatShouldBeSaved };
                     if (!CheckArguments(args, method))
                         continue;
 
-                    string[] result = (string[])method.Invoke(null, args);
+                    string[] result;
+                    using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto())
+                        result = (string[])method.Invoke(null, args);
 
                     if (result != null)
                         assetsThatShouldBeSaved = result;
@@ -195,14 +203,16 @@ static AssetMoveResult OnWillMoveAsset(string fromPath, string toPath, string[]
 
             foreach (var assetModificationProcessorClass in AssetModificationProcessors)
             {
-                MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillMoveAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "OnWillMoveAsset";
+                MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method != null)
                 {
                     object[] args = { fromPath, toPath };
                     if (!CheckArgumentsAndReturnType(args, method, finalResult.GetType()))
                         continue;
 
-                    finalResult |= (AssetMoveResult)method.Invoke(null, args);
+                    using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto())
+                        finalResult |= (AssetMoveResult)method.Invoke(null, args);
                 }
             }
 
@@ -215,14 +225,16 @@ static AssetDeleteResult OnWillDeleteAsset(string assetPath, RemoveAssetOptions
 
             foreach (var assetModificationProcessorClass in AssetModificationProcessors)
             {
-                MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillDeleteAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "OnWillDeleteAsset";
+                MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method != null)
                 {
                     object[] args = { assetPath, options };
                     if (!CheckArgumentsAndReturnType(args, method, finalResult.GetType()))
                         continue;
 
-                    finalResult |= (AssetDeleteResult)method.Invoke(null, args);
+                    using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto())
+                        finalResult |= (AssetDeleteResult)method.Invoke(null, args);
                 }
             }
 
@@ -243,7 +255,8 @@ static void OnWillDeleteAssets(string[] assetPaths, AssetDeleteResult[] outPathD
             List<int> nonDeletedPathIndices = new List<int>();
             foreach (var assetModificationProcessorClass in AssetModificationProcessors)
             {
-                MethodInfo method = assetModificationProcessorClass.GetMethod("OnWillDeleteAsset", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "OnWillDeleteAsset";
+                MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method == null)
                     continue;
 
@@ -253,8 +266,12 @@ static void OnWillDeleteAssets(string[] assetPaths, AssetDeleteResult[] outPathD
                     if (!CheckArgumentsAndReturnType(args, method, typeof(AssetDeleteResult)))
                         continue;
 
-                    AssetDeleteResult callbackResult = (AssetDeleteResult)method.Invoke(null, args);
-                    outPathDeletionResults[i] |= callbackResult;
+
+                    using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto())
+                    {
+                        AssetDeleteResult callbackResult = (AssetDeleteResult)method.Invoke(null, args);
+                        outPathDeletionResults[i] |= callbackResult;
+                    }
                 }
             }
 
@@ -531,14 +548,16 @@ internal static void OnStatusUpdated()
 
             foreach (var assetModificationProcessorClass in AssetModificationProcessors)
             {
-                MethodInfo method = assetModificationProcessorClass.GetMethod("OnStatusUpdated", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "OnStatusUpdated";
+                MethodInfo method = assetModificationProcessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method != null)
                 {
                     object[] args = {};
                     if (!CheckArgumentsAndReturnType(args, method, typeof(void)))
                         continue;
 
-                    method.Invoke(null, args);
+                    using (new EditorPerformanceMarker($"{assetModificationProcessorClass.Name}.{methodName}", assetModificationProcessorClass).Auto())
+                        method.Invoke(null, args);
                 }
             }
         }

Editor/Mono/AssetPostprocessor.cs

@@ -95,16 +95,17 @@ static void PostprocessAllAssets(string[] importedAssets, string[] addedAssets,
             object[] args = { importedAssets, deletedAssets, movedAssets, movedFromPathAssets };
             foreach (var assetPostprocessorClass in GetCachedAssetPostprocessorClasses())
             {
-                MethodInfo method = assetPostprocessorClass.GetMethod("OnPostprocessAllAssets", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                const string methodName = "OnPostprocessAllAssets";
+                MethodInfo method = assetPostprocessorClass.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                 if (method != null)
                 {
-                    InvokeMethod(method, args);
+                    using (new EditorPerformanceMarker($"{assetPostprocessorClass.Name}.{methodName}", assetPostprocessorClass).Auto())
+                        InvokeMethod(method, args);
                 }
             }
 
-            Profiler.BeginSample("SyncVS.PostprocessSyncProject");
-            CodeEditorProjectSync.PostprocessSyncProject(importedAssets, addedAssets, deletedAssets, movedAssets, movedFromPathAssets);
-            Profiler.EndSample();
+            using (new EditorPerformanceMarker("SyncVS.PostprocessSyncProject").Auto())
+                CodeEditorProjectSync.PostprocessSyncProject(importedAssets, addedAssets, deletedAssets, movedAssets, movedFromPathAssets);
         }
 
         [RequiredByNativeCode]
@@ -647,7 +648,7 @@ static void CallPostProcessMethods(string methodName, object[] args)
         static object InvokeMethod(MethodInfo method, object[] args)
         {
             object res = null;
-            using (new EditorPerformanceTracker(method.DeclaringType.Name + "." + method.Name))
+            using (new EditorPerformanceMarker(method.DeclaringType.Name + "." + method.Name, method.DeclaringType).Auto())
             {
                 res = method.Invoke(null, args);
             }
@@ -657,10 +658,11 @@ static object InvokeMethod(MethodInfo method, object[] args)
 
         static bool InvokeMethodIfAvailable(object target, string methodName, object[] args)
         {
-            MethodInfo method = target.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            var type = target.GetType();
+            MethodInfo method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
             if (method != null)
             {
-                using (new EditorPerformanceTracker(target.GetType().Name + "." + methodName))
+                using (new EditorPerformanceMarker(type.Name + "." + methodName, type).Auto())
                 {
                     method.Invoke(target, args);
                 }
@@ -672,10 +674,11 @@ static bool InvokeMethodIfAvailable(object target, string methodName, object[] a
 
         static bool InvokeMethodIfAvailable<T>(object target, string methodName, object[] args, ref T returnedObject) where T : class
         {
-            MethodInfo method = target.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            var type = target.GetType();
+            MethodInfo method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
             if (method != null)
             {
-                using (new EditorPerformanceTracker(target.GetType().Name + "." + methodName))
+                using (new EditorPerformanceMarker(type.Name + "." + methodName, type).Auto())
                 {
                     returnedObject = method.Invoke(target, args) as T;
                 }