c# 第一次各种方法实现反编译.dll文件的雏形，供后续学习

下面的代码仿照下图要实现下面的反编译图功能


using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace WindowsFormsApp02
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void fIleToolStripMenuItem_Click(object sender, EventArgs e)
        {
            //StringBuilder sb = new StringBuilder();

            //OpenFileDialog dlg = new OpenFileDialog();
            //if (dlg.ShowDialog() == DialogResult.OK) ;
            //MessageBox.Show(dlg.FileName);
            //String  str = dlg.FileName;
            ////Console.WriteLine(str);
            //Assembly asm = Assembly.LoadFile(str);
            //MessageBox.Show("加载文件完毕");

            ////string name = asm.FullName;
            ////String mod = asm.GetModule();

            //Type[] types = asm.GetTypes();

            //foreach (Type t in types)
            //{
            //    sb.Append("   类型：" + t + "\n");
            //    //TypeExplore(t);
            //    //MemberExplore(t);
            //    //FieldExplore(t);
            //}

            //var asem = new TreeNode("Assembly");
            //this.treeView1.Nodes.AddRange(new TreeNode[] { asem, new TreeNode("A"), new TreeNode("B") , new TreeNode("C") });

            //var module1 = new TreeNode("Module1");
            //var module2 = new TreeNode("Module2");
            //asem.Nodes.Add(module1);
            //asem.Nodes.Add(module2);
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        //public class MyTreeNode
        //{
        //    public string Text { get; set; }

        //    public MyTreeNode Left { get; set; }

        //    public MyTreeNode Right { get; set; }
        //}

        private void openAssemblyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            var openFile = new OpenFileDialog();
            if (openFile.ShowDialog(this) == DialogResult.OK)
            {
              
                var assembly = Assembly.LoadFile(openFile.FileName);
                var assemNode = new TreeNode(assembly.GetName().Name);
                this.treeView1.Nodes.Add(assemNode);
               


                var modules = assembly.GetModules();
                for (int i = 0; i < modules.Length; i++)
                {
                    var moduleNode = new TreeNode(modules[i].Name);
                    assemNode.Nodes.Add(moduleNode);

                    //    var Reference = new TreeNode(ModuleName.Name);
                    //     ModuleName.Nodes.Add(Reference);

                    //        var mscorlib = new TreeNode(Reference.Name);
                    //         Reference.Nodes.Add(mscorlib);

                    //var Derived = new TreeNode(ModuleName.Name);
                    ////ModuleName.Nodes.Add(Derived);

                    var referenceNode = new TreeNode("References");
                    moduleNode.Nodes.Add(referenceNode);
                    var refs = assembly.GetReferencedAssemblies();
                    foreach (var refName in refs)
                    {
                        referenceNode.Nodes.Add(new TreeNode(refName.Name));
                    }


                    var typearr = modules[i].GetTypes();
                    
                    var typeGroup = new System.Collections.Generic.Dictionary<String ,List<Type>>();
                    foreach (var type in typearr)
                    {
                        var np = type.Namespace;
                        if (string.IsNullOrEmpty(np)) np = "-";
                        if (typeGroup.ContainsKey(np)) 
                        {
                           
                            typeGroup[np].Add(type);
                            continue;
                        }
                        else
                        { 
                            var newList = new List<Type>();
                            newList.Add(type);
                            typeGroup.Add(np,newList);
                        }
                    }


                    foreach (var typeItem in typeGroup)
                    {
                        var namespaceNode = new TreeNode(typeItem.Key);
                         moduleNode.Nodes.Add(namespaceNode);
                        foreach (var type in typeItem.Value)
                        {
                            var typeNode = new TreeNode(type.Name);
                            namespaceNode.Nodes.Add(typeNode);

                            //Do Const

                            var consts = type.GetConstructors(BindingFlags.Public |
                                                            BindingFlags.Static |
                                                            BindingFlags.NonPublic |
                                                            BindingFlags.Instance |
                                                            BindingFlags.DeclaredOnly 
                                                          );
                            foreach(var con in consts) 
                            {
                               
                                var conParameters = con.GetParameters();
                                var list = new List<String >();
                                foreach (var conParameter in conParameters)
                                {
                                    list.Add(conParameter.ParameterType.Name);
                                }


                                var coninfo = new TreeNode(con.Name + "(" +String.Join(",",list.ToArray() ) + ")" );
                                typeNode.Nodes.Add(coninfo);
                            }

                            //method
                            var methods = type.GetMethods(BindingFlags.Public |
                                                            BindingFlags.Static |
                                                            BindingFlags.NonPublic |
                                                            BindingFlags.Instance |
                                                            BindingFlags.DeclaredOnly);
                            foreach (var method in methods)
                            {
                                var methodName = method.Name;
                                if (methodName.StartsWith("set_") || methodName.StartsWith("get_"))
                                {
                                    if (method.IsSpecialName)
                                    {
                                        continue;
                                    }
                                }
                                var parameters = method.GetParameters();
                                //var list = new List<String>();

                                //foreach (var parameter in parameters )
                                //{
                                //    var para = parameter.ParameterType.Name;

                                //     list.Add(para);
                                //}

                                //方法一测试
                                var list = new List<String>();
                                foreach (var parameter in parameters)
                                {
                                    list.Add(parameter.ParameterType.Name);
                                }
                                var methodInfoNode = new TreeNode(method.Name + "(" + String.Join(", ", list.ToArray()) + ")"+" : " + method.ReturnType.Name);
                                typeNode.Nodes.Add(methodInfoNode);



                                //方法2
                                //string pamStr = string.Empty;
                                //foreach (var parameter in parameters)
                                //{
                                //    var para = parameter.ParameterType.Name;

                                //    pamStr += ((string.IsNullOrEmpty(pamStr) ? string.Empty : ", ") + parameter.ParameterType.Name);
                                //}

                                //var methodInfoNode = new TreeNode(method.Name + "(" + pamStr + ")" + " : " + method.ReturnType.Name);
                                //typeNode.Nodes.Add(methodInfoNode);
                               
                                //}

                                //filds
                                //var isTrueNode = new TreeNode("IsTrue :Boolean");
                                //typeNode.Nodes.Add(isTrueNode);

                                //var filds = type.GetFields();
                                //foreach (var fildsInfo in filds)
                                //{
                                //    var fildNode = new TreeNode(fildsInfo.Name);
                                //    typeNode.Nodes.Add(fildNode);
                                //}                              
                            }
                            //property
                            var properties = type.GetProperties();
                            foreach (var property in properties)
                            {
                                var proNode = new TreeNode(property.Name + ": " + property.PropertyType.Name);
                                typeNode.Nodes.Add(proNode);
                                if (property.CanRead)
                                {
                                    var method = property.GetGetMethod();
                                    var parameters = method.GetParameters();
                                    var list = new List<String>();
                                    foreach (var parameter in parameters)
                                    {
                                        list.Add(parameter.ParameterType.Name);
                                    }
                                    var methodInfoNode = new TreeNode(method.Name + "(" + String.Join(",", list.ToArray()) + ")" + ": " + method.ReturnType.Name);
                                    proNode.Nodes.Add(methodInfoNode);
                                }
                                if (property.CanWrite)
                                {
                                    var method = property.GetSetMethod();
                                    var parameters = method.GetParameters();
                                    var list = new List<String>();
                                    foreach (var parameter in parameters)
                                    {
                                        list.Add(parameter.ParameterType.Name);
                                    }
                                    var methodInfoNode = new TreeNode(method.Name + "(" + String.Join(",", list.ToArray()) + ")" + ": " + method.ReturnType.Name);
                                    proNode.Nodes.Add(methodInfoNode);
                                }
                            }

                            //filds
                            //var isTrueNode = new TreeNode("IsTrue :Boolean");
                            //typeNode.Nodes.Add(isTrueNode);

                            var filds = type.GetFields(BindingFlags.Public |
                                                            BindingFlags.Static |
                                                            BindingFlags.NonPublic |
                                                            BindingFlags.Instance |
                                                            BindingFlags.DeclaredOnly);
                            foreach (var fildsInfo in filds)
                            {
                                var fildNode = new TreeNode(fildsInfo.Name + ": "+ fildsInfo.FieldType.Name);
                                typeNode.Nodes.Add(fildNode );
                            }
                        }


                    }
                   
                    //for (int j = 0; j < typearr.Length; j++)
                    //{                      
                    //    for (int k = 0 ; k < j; k++) {
                    //        if (typearr[j].Namespace.Equals(typearr[k].Namespace))
                    //        {
                    //            //var namespaceNode = new TreeNode(typearr[k].Namespace);
                    //            //var nodes = moduleNode.Nodes;
                    //            //foreach (TreeNode node in nodes) {
                    //            //    if (node.Text.Equals(typearr[j].Namespace)) {

                    //            //        node.Nodes.Add(new TreeNode(typearr[k].Name));

                    //            ArrayList arraylist = new ArrayList();
                    //            arraylist.Add(typearr[j].Name);
                    //            foreach (var  list in arraylist)
                    //            {

                    //                var namespaceNode = new TreeNode(typearr[j].Namespace);
                    //                moduleNode.Nodes.Add(namespaceNode);
                    //                namespaceNode.Nodes.Add(new TreeNode(typearr[j].Name));





                    //            }

                    //            //var namespaceNode = new TreeNode(typearr[k].Namespace);
                    //            //moduleNode.Nodes.Add(namespaceNode);

                    //            //namespaceNode.Nodes.Add(new TreeNode(typearr[k].Name));
                    //        }   
                    //        //else {
                    //        //    var namespaceNode = new TreeNode(typearr[j].Namespace);
                    //        //    moduleNode.Nodes.Add(namespaceNode);
                    //        //    namespaceNode.Nodes.Add(new TreeNode(typearr[j].Name));
                    //        //}
                    //        else {
                    //            ArrayList array2 = new ArrayList();
                    //            array2.Add(typearr[j].Name);

                    //        }
                    //    }
                    //}






                    // var typearr = modules[i].GetTypes();//获取类型 
                    //foreach (var type in typearr)//针对每个类型获取详细信息  
                    //{
                    //     //获取类型的结构信息 
                    //     constructorinfo[] myconstructors = type.GetConstructors;
                    //     for (int i = 1; i < myconstructors.Length; i++) {
                    //         var cons = new TreeNodes(myconstructors[i].name);
                    //      //   Derived.nodes.Add(cons);
                    //     }


                    //         //获取类型的字段信息  
                    //         fieldinfo[] myfields = type.GetFiedls();
                    //     //获取方法信息  
                    //     MethodInfo myMethodInfo = type.GetMethods();
                    //     //获取属性信息  
                    //     propertyInfo[] myproperties = type.GetProperties;
                    //     //获取事件信息  
                    //     EventInfo[] Myevents = type.GetEvents;

                    // }
                    //foreach (var item in classes)
                    //{

                    //    var nodes = new TreeNode(item.Name);
                    //    ModuleName.Nodes.Add(nodes);

                    //    var Object = new TreeNode(item.BaseType.Name);
                    //    nodes.Nodes.Add(Object);



                    //    ConstructorInfo [] myconstuct = item.GetConstructors;
                    //    Fieldinfo[] myfields = item.GetFiedls()



                    ////}
                    //MemberInfo[] members = t.GetMembers();
                    //foreach (var m in members) {

                    //}











                }
            }
        }
    }





}