/// <summary>
        /// Get all members in the given type
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public ObservableCollection <BindableObjectExtended> GetMembers(NetBaseType type)
        {
            ObservableCollection <BindableObjectExtended> list = new ObservableCollection <BindableObjectExtended>();

            TypeDefinition modulType = (TypeDefinition)type.Tag;

            ProcessCecilMethod(modulType.Constructors, type);
            ProcessCecilMethod(modulType.Methods, type);

            foreach (MethodDefinition constructorType in modulType.Constructors)
            {
                list.Add(AddMethod(MethodType.Constructor, constructorType));
            }
            foreach (MethodDefinition methodType in modulType.Methods)
            {
                list.Add(new NetMethod(MethodType.Method, methodType)
                {
                    Name = methodType.Name
                });
            }

            return(list);
        }
        /// <summary>
        /// Loop through a cecil methods collection
        /// </summary>
        /// <param name="cecilMethods"></param>
        /// <param name="classTyp"></param>
        private void ProcessCecilMethod(CollectionBase cecilMethods, NetBaseType classTyp)
        {
            foreach (MethodDefinition def in cecilMethods)
            {
                if (!RefreshMethod(classTyp.Children, def))
                {
                    if (cecilMethods.GetType() == typeof(ConstructorCollection))
                    {
                        AddMethod(MethodType.Constructor, def);
                    }
                    if (cecilMethods.GetType() == typeof(MethodDefinitionCollection))
                    {
                        AddMethod(MethodType.Method, def);
                    }
                    if (cecilMethods.GetType() == typeof(PropertyDefinitionCollection))
                    {
                        AddMethod(MethodType.Property, def);
                    }
                    if (cecilMethods.GetType() == typeof(EventDefinitionCollection))
                    {
                        AddMethod(MethodType.Event, def);
                    }
                    if (cecilMethods.GetType() == typeof(FieldDefinitionCollection))
                    {
                        AddMethod(MethodType.Field, def);
                    }
                    if (cecilMethods.GetType() == typeof(InterfaceCollection))
                    {
                        AddMethod(MethodType.Interface, def);
                    }

                    //process nested types
                    //if (cecilMethods.GetType() == typeof(NestedTypeCollection))
                }
            }
        }
 /// <summary>
 /// Refresh a assembly element and all subtypes if loaded
 /// </summary>
 /// <param name="node"></param>
 public void RefreshNode(NetBaseType node)
 {
 }
        /// <summary>
        /// Get all members in the given type
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public ObservableCollection <BindableObjectExtended> GetMembers(NetBaseType type)
        {
            BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static
                                 | BindingFlags.Instance | BindingFlags.DeclaredOnly;

            ObservableCollection <BindableObjectExtended> list = new ObservableCollection <BindableObjectExtended>();

            ConstructorInfo[] cinfo = ((Type)type.Tag).GetConstructors(flags);
            foreach (ConstructorInfo mi in cinfo)
            {
                list.Add(new NetMethod(MethodType.Constructor, mi)
                {
                    Name = mi.Name
                });
            }

            //MemberInfo[] memberinfo = ((Type)type.Tag).GetMembers(flags);
            //foreach (MemberInfo mi in memberinfo)
            //{
            //    list.Add(new NetMethod(mi) { Name = mi.Name });
            //}

            FieldInfo[] fieldinfo = ((Type)type.Tag).GetFields(flags);
            foreach (FieldInfo mi in fieldinfo)
            {
                list.Add(new NetMethod(MethodType.Field, mi)
                {
                    Name = mi.Name
                });
            }

            PropertyInfo[] propinfo = ((Type)type.Tag).GetProperties(flags);
            foreach (PropertyInfo mi in propinfo)
            {
                list.Add(new NetMethod(MethodType.Property, mi)
                {
                    Name = mi.Name
                });
            }

            MethodInfo[] methodinfo = ((Type)type.Tag).GetMethods(flags);
            foreach (MethodInfo mi in methodinfo)
            {
                if (!mi.Name.Contains("get_") && !mi.Name.Contains("set_"))
                {
                    list.Add(new NetMethod(MethodType.Method, mi)
                    {
                        Name = mi.Name
                    });
                }
            }

            Type[] inter = ((Type)type.Tag).GetInterfaces();
            foreach (Type mi in inter)
            {
                list.Add(new NetMethod(MethodType.Interface, mi)
                {
                    Name = mi.Name
                });
            }

            EventInfo[] eventinfo = ((Type)type.Tag).GetEvents();
            foreach (EventInfo mi in eventinfo)
            {
                list.Add(new NetMethod(MethodType.Event, mi)
                {
                    Name = mi.Name
                });
            }

            return(list);
        }