Exemple #1
0
        public void TestGetExtensionMethods_NoResult()
        {
            Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a =>
                                                                                       a.FullName.StartsWith("nunit", StringComparison.Ordinal));
            var extensions = TypeSystem.GetExtensionMethods(new[] { assembly });

            Assert.IsFalse(extensions.TryGetValue(typeof(FakeNoOverload), out _));
        }
Exemple #2
0
        public void TestGetExtensionMethods()
        {
            Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a =>
                                                                                       a.FullName.StartsWith("Unity.GraphTools.Foundation.Editor.Tests", StringComparison.Ordinal));
            var extensions = TypeSystem.GetExtensionMethods(new[] { assembly });

            Assert.IsTrue(extensions.TryGetValue(typeof(FakeNoOverload), out var methods));
            Assert.AreEqual(2, methods.Count);
            Assert.AreEqual("Ext1", methods[0].Name);
            Assert.AreEqual("Ext2", methods[1].Name);
        }
Exemple #3
0
        public GraphElementSearcherDatabase AddExtensionMethods(Type type)
        {
            Dictionary <Type, List <MethodInfo> > extensions = TypeSystem.GetExtensionMethods(Stencil.GetAssemblies());

            if (!extensions.TryGetValue(type, out var methodInfos))
            {
                return(this);
            }

            SearcherItem parent = null;

            foreach (MethodInfo methodInfo in methodInfos
                     .Where(m => !m.GetParameters().Any(p => p.ParameterType.IsByRef || p.IsOut)))
            {
                if (parent == null)
                {
                    parent = SearcherItemUtility.GetItemFromPath(Items, type.FriendlyName(false));
                }

                MethodDetails details = methodInfo.GetMethodDetails();

                if (methodInfo.ReturnType != typeof(void))
                {
                    parent.AddChild(new GraphNodeModelSearcherItem(
                                        new MethodSearcherItemData(methodInfo),
                                        data => ((VSGraphModel)data.GraphModel).CreateFunctionCallNode(
                                            methodInfo,
                                            data.Position,
                                            data.SpawnFlags
                                            ),
                                        details.MethodName,
                                        details.Details
                                        ));
                    continue;
                }

                parent.AddChild(new StackNodeModelSearcherItem(
                                    new MethodSearcherItemData(methodInfo),
                                    data => ((StackBaseModel)data.StackModel).CreateFunctionCallNode(
                                        methodInfo,
                                        data.Index,
                                        data.SpawnFlags
                                        ),
                                    details.MethodName,
                                    details.Details
                                    ));
            }

            return(this);
        }
        static Dictionary <Type, MethodInfo> FindMatchingExtensionMethods <TAttribute>(Func <MethodInfo, bool> filterMethods, Func <MethodInfo, Type> keySelector) where TAttribute : Attribute
        {
            var factoryMethods = new Dictionary <Type, MethodInfo>();

            var  assemblies       = Stencil.CachedAssemblies;
            var  extensionMethods = TypeSystem.GetExtensionMethods <TAttribute>(assemblies);
            Type extendedType     = typeof(TExtendedType);

            if (extensionMethods.TryGetValue(extendedType, out var allMethodInfos))
            {
                foreach (var methodInfo in allMethodInfos.Where(filterMethods))
                {
                    var key = keySelector(methodInfo);
                    if (factoryMethods.TryGetValue(key, out var prevValue))
                    {
                        Debug.LogError($"Duplicate extension methods for type {key}, previous value: {prevValue}, new value: {methodInfo}, extended type: {extendedType.FullName}");
                    }

                    factoryMethods[key] = methodInfo;
                }
            }

            return(factoryMethods);
        }