Exemple #1
0
        void Load(string path)
        {
            var assembly = AssemblyLoader.GetAssembly(path);
            var types    = assembly.GetTypes().Where(t =>
                                                     !t.IsDefined(typeof(CompilerGeneratedAttribute), false) &&
                                                     !t.IsEnum &&
                                                     !t.IsNotPublic &&
                                                     !t.IsSubclassOf(typeof(Delegate)));

            foreach (Type type in types)
            {
                string typeName = type.Name;
                var    t        = new API(Category.Type, typeName);
                apis.Add(t);

                var staticFieldsInfo = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)
                                       .Where(f => f.IsFamily || f.IsPublic);
                foreach (var field in staticFieldsInfo)
                {
                    var api = new API(t, Category.StaticField, field.Name, field.FieldType.Name);
                    apis.Add(api);
                    NameMap[field] = api;
                }

                var propertyInfo = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
                                   .Where(p => (p.GetMethod != null && !p.GetMethod.IsPrivate) || (p.SetMethod != null && !p.SetMethod.IsPrivate));
                foreach (var property in propertyInfo)
                {
                    var api = new API(t, Category.Property, property.Name, property.PropertyType.Name);
                    apis.Add(api);

                    if (property.GetMethod != null)
                    {
                        NameMap[property.GetMethod] = api;
                        //Console.WriteLine($"{property.GetMethod.Name} => {property.GetMethod.GetMetadataToken():x} / {property.GetMethod.MetadataToken:x}");
                    }
                    if (property.SetMethod != null)
                    {
                        NameMap[property.SetMethod] = api;
                        //Console.WriteLine($"{property.SetMethod.Name} => {property.SetMethod.GetMetadataToken():x} / {property.SetMethod.MetadataToken:x}");
                    }
                }

                var methodInfo = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static).Where(m => {
                    if (!m.IsFamily && !m.IsPublic)
                    {
                        return(false);
                    }
                    var method = m as MethodBase;
                    return(method == null || !method.IsSpecialName);
                });
                foreach (var method in methodInfo)
                {
                    var pars = method.GetParameters();
                    var psb  = new StringBuilder();
                    psb.Append(' ');
                    foreach (var p in pars)
                    {
                        psb.Append(p.ParameterType.Name);
                        psb.Append(' ');
                        psb.Append(p.Name);
                        psb.Append(' ');
                    }

                    var api = new API(t, Category.Method, $"{method.Name}({psb.ToString()})", method.ReturnType.Name);
                    apis.Add(api);
                    NameMap[method] = api;
                }

                var fieldsInfo = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
                                 .Where(m => m.IsFamily || m.IsPublic);
                foreach (var field in fieldsInfo)
                {
                    var api = new API(t, Category.Field, field.Name, field.FieldType.Name);
                    apis.Add(api);
                    NameMap[field] = api;
                }

                var eventsInfo = type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
                                 .Where(e => !e.AddMethod.IsPrivate || !e.RemoveMethod.IsPrivate);
                foreach (var evnt in eventsInfo)
                {
                    var api = new API(t, Category.Event, evnt.Name, evnt.EventHandlerType.Name);
                    apis.Add(api);

                    if (evnt.AddMethod != null)
                    {
                        NameMap[evnt.AddMethod] = api;
                    }
                    if (evnt.RemoveMethod != null)
                    {
                        NameMap[evnt.RemoveMethod] = api;
                    }
                }
            }
        }