home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 40 / IOPROG_40.ISO / SOFT / NETFrameworkSDK.exe / comsdk.cab / samples.exe / QuickStart / aspplus / samples / classbrowser / ClassInfo.cs < prev    next >
Encoding:
Text File  |  2000-05-10  |  19.8 KB  |  513 lines
  1. using System ;
  2. using System.Web;
  3. using System.Web.UI; 
  4. using System.Collections;
  5. using System.Reflection;
  6.  
  7. namespace ClassInfo
  8. {
  9.  
  10. public class SortTable : Hashtable, IComparable
  11.    {
  12.        public String sortField;
  13.     
  14.        public SortTable(String sField)
  15.        {
  16.            sortField= sField;
  17.        }
  18.  
  19.        public int CompareTo(Object b)
  20.        {
  21.             return ((String)this[sortField]).CompareTo((String)((SortTable)b)[sortField]);
  22.        }
  23.    }
  24.  
  25.  
  26.  
  27.  
  28. public class DisplayFields : ArrayList
  29. { 
  30.     public  DisplayFields(Type classType) 
  31.     {
  32.         System.Reflection.FieldInfo[] fieldInfos = classType.GetFields();
  33.  
  34.         if (fieldInfos == null)
  35.             return;
  36.                
  37.         ArrayList fieldTable = new ArrayList();
  38.  
  39.         for (int x=0; x<fieldInfos.Length; x++)
  40.         {
  41.             SortTable fieldDetails = new SortTable("Name");
  42.  
  43.             fieldDetails["Name"] = fieldInfos[x].Name;
  44.             fieldDetails["Type"] = fieldInfos[x].FieldType.Name;
  45.             if(( fieldInfos[x].FieldType.IsArray && fieldInfos[x].FieldType.Name != "Array") ||  fieldInfos[x].FieldType.IsPointer)
  46.             {
  47.                 fieldDetails["GetType"]   = fieldInfos[x].FieldType.GetElementType().Name;
  48.                 fieldDetails["Namespace"] = fieldInfos[x].FieldType.GetElementType().Namespace;
  49.             }
  50.             else
  51.             {
  52.                 fieldDetails["GetType"]   = fieldInfos[x].FieldType.Name;
  53.                 fieldDetails["Namespace"] = fieldInfos[x].FieldType.Namespace;
  54.             }
  55.             if (fieldInfos[x].IsPublic == true) 
  56.             {
  57.                 fieldDetails["Access"] = "public ";
  58.             }
  59.             else if (fieldInfos[x].IsPrivate == true) 
  60.             {
  61.                 fieldDetails["Access"] = "private ";
  62.             }     
  63.             else if (fieldInfos[x].IsFamily == true) 
  64.             {
  65.                 fieldDetails["Access"] = "protected ";
  66.             }                  
  67.  
  68.             if (fieldInfos[x].IsStatic == true) 
  69.             {
  70.                 fieldDetails["Access"] = ((String) fieldDetails["Access"]) + "static ";
  71.             }
  72.  
  73.             if (fieldInfos[x].IsLiteral == true) 
  74.             {
  75.                 fieldDetails["Access"] = ((String) fieldDetails["Access"]) + "const ";
  76.             }
  77.  
  78.             this.Add(fieldDetails);
  79.        }
  80.          this.Sort();
  81.     }
  82. }
  83.  
  84. public class DisplayConstructors : ArrayList
  85. {
  86.     public DisplayConstructors(Type classType)
  87.     {
  88.         System.Reflection.ConstructorInfo[] constructorInfos = classType.GetConstructors();
  89.         
  90.         if (constructorInfos == null)
  91.             return;
  92.                
  93.         for (int x=0; x<constructorInfos.Length; x++) 
  94.         {
  95.             Hashtable constructorDetails = new Hashtable();
  96.  
  97.             constructorDetails["Name"] = classType.Name;
  98.  
  99.             if (constructorInfos[x].IsPublic == true) 
  100.             {
  101.                 constructorDetails["Access"] = "public ";
  102.             }
  103.             else if (constructorInfos[x].IsPrivate == true) 
  104.             {
  105.                 constructorDetails["Access"] = "private ";
  106.             }     
  107.             else if (constructorInfos[x].IsFamily == true) 
  108.             {
  109.                 constructorDetails["Access"] = "protected ";
  110.             }    
  111.  
  112.             System.Reflection.ParameterInfo[] paramInfos = constructorInfos[x].GetParameters();
  113.  
  114.             if (paramInfos != null)
  115.             {
  116.                 ArrayList paramTable = new ArrayList();
  117.                 for (int y=0; y<paramInfos.Length; y++)
  118.                 {     
  119.                     Hashtable paramDetails = new Hashtable();
  120.                     paramDetails["ParamName"] = paramInfos[y].Name;
  121.                     paramDetails["ParamType"] = paramInfos[y].ParameterType.Name;    
  122.                     if ( ( paramInfos[y].ParameterType.IsArray && paramInfos[y].ParameterType.Name !="Array" ) || paramInfos[y].ParameterType.IsPointer )  
  123.                     {
  124.                         paramDetails["GetType"]   = paramInfos[y].ParameterType.GetElementType().Name ;
  125.                         paramDetails["Namespace"] = paramInfos[y].ParameterType.GetElementType().Namespace ;
  126.                     }
  127.   
  128.                     else  
  129.                     {
  130.                     paramDetails["GetType"]   = paramInfos[y].ParameterType.Name;
  131.                         paramDetails["Namespace"] = paramInfos[y].ParameterType.Namespace ;
  132.                     }
  133.                     paramTable.Add(paramDetails); 
  134.                 }
  135.                  
  136.                 constructorDetails["Params"] = paramTable;
  137.             }    
  138.  
  139.             this.Add(constructorDetails);
  140.         }  
  141.     }
  142. }
  143.  
  144.  
  145. public class DisplayProperties : ArrayList
  146. {
  147.     public  DisplayProperties(Type classType) 
  148.     {
  149.         System.Reflection.PropertyInfo[] propertyInfos = classType.GetProperties();
  150.  
  151.         if (propertyInfos == null)
  152.             return;
  153.                
  154.         ArrayList propertyTable = new ArrayList();
  155.          
  156.         for (int x=0; x<propertyInfos.Length; x++)
  157.         {
  158.                          
  159.             SortTable propertyDetails = new SortTable("Name");
  160.                 
  161.             if(propertyInfos[x].GetGetMethod() != null)
  162.             {
  163.                 if(( propertyInfos[x].GetGetMethod().ReturnType.IsArray && propertyInfos[x].GetGetMethod().ReturnType.Name !="Array" ) || propertyInfos[x].GetGetMethod().ReturnType.IsPointer )
  164.                 {   
  165.                     propertyDetails["GetType"] = propertyInfos[x].GetGetMethod().ReturnType.GetElementType().Name;
  166.                     propertyDetails["Namespace"]=propertyInfos[x].GetGetMethod().ReturnType.GetElementType().Namespace;
  167.              
  168.                 }
  169.                 else
  170.                 {
  171.                     propertyDetails["GetType"] = propertyInfos[x].GetGetMethod().ReturnType.Name; 
  172.                     propertyDetails["Namespace"] = propertyInfos[x].GetGetMethod().ReturnType.Namespace;
  173.                 }
  174.                 propertyDetails["Type"] = propertyInfos[x].GetGetMethod().ReturnType.Name; 
  175.                 propertyDetails["Name"] = propertyInfos[x].Name;
  176.                
  177.                 if (propertyInfos[x].GetGetMethod().IsPublic == true) 
  178.                 {
  179.                      propertyDetails["Visibility"] = "public";
  180.                 }
  181.                 else if (propertyInfos[x].GetGetMethod().IsPrivate == true) 
  182.                 {
  183.                      propertyDetails["Visibility"] = "private";
  184.                 }     
  185.                 else if (propertyInfos[x].GetGetMethod().IsFamily == true) 
  186.                 {
  187.                     propertyDetails["Visibility"] = "protected";
  188.                 }                  
  189.                
  190.                 if (propertyInfos[x].GetGetMethod().IsStatic == true) 
  191.                 {
  192.                     propertyDetails["Visibility"] = ((String) propertyDetails["Visibility"]) + " static";
  193.                 }
  194.                   
  195.                 if (propertyInfos[x].GetSetMethod() == null)
  196.                 { 
  197.                     propertyDetails["Access"] =  "[Get]" ; 
  198.                 }
  199.             else
  200.                 {
  201.                 propertyDetails["Access"] = "[Get , Set]" ;
  202.             }    
  203.                   
  204.                 System.Reflection.ParameterInfo[] paramInfos = propertyInfos[x].GetGetMethod().GetParameters();
  205.                 
  206.                 if (paramInfos != null)
  207.                 {
  208.                     ArrayList paramTable = new ArrayList();
  209.                  
  210.                     for (int y=0; y<paramInfos.Length; y++)
  211.                     {     
  212.                         Hashtable paramDetails = new Hashtable();
  213.                         paramDetails["ParamName"] = paramInfos[y].Name;
  214.                         paramDetails["ParamType"] = paramInfos[y].ParameterType.Name;    
  215.                         if (( paramInfos[y].ParameterType.IsArray && paramInfos[y].ParameterType.Name !="Array") ||paramInfos[y].ParameterType.IsPointer )  
  216.                         {
  217.                             paramDetails["GetType"]   = paramInfos[y].ParameterType.GetElementType().Name ;
  218.                             paramDetails["Namespace"] = paramInfos[y].ParameterType.GetElementType().Namespace ;
  219.                         }
  220.                         else  
  221.                         {
  222.                         paramDetails["GetType"]   = paramInfos[y].ParameterType.Name;
  223.                             paramDetails["Namespace"] = paramInfos[y].ParameterType.Namespace ;
  224.                         }
  225.                         paramTable.Add(paramDetails); 
  226.                     }
  227.                  
  228.                     propertyDetails["Params"] = paramTable;
  229.                }
  230.             }
  231.             else if(propertyInfos[x].GetSetMethod() != null)
  232.             {
  233.                 
  234.                 propertyDetails["GetType"] = propertyInfos[x].GetSetMethod().ReturnType.Name; 
  235.                 propertyDetails["Namespace"] = propertyInfos[x].GetSetMethod().ReturnType.Namespace;
  236.               
  237.                 propertyDetails["Type"] = propertyInfos[x].GetSetMethod().ReturnType.Name; 
  238.                 propertyDetails["Name"] = propertyInfos[x].Name;
  239.             
  240.                 if (propertyInfos[x].GetSetMethod().IsPublic == true) 
  241.                 {
  242.                      propertyDetails["Visibility"] = "public";
  243.                 }
  244.                 else if (propertyInfos[x].GetSetMethod().IsPrivate == true) 
  245.                 {
  246.                      propertyDetails["Visibility"] = "private";
  247.                 }     
  248.                 else if (propertyInfos[x].GetSetMethod().IsFamily == true) 
  249.                 {
  250.                     propertyDetails["Visibility"] = "protected";
  251.                 }                  
  252.               
  253.                 if (propertyInfos[x].GetSetMethod().IsStatic == true) 
  254.                 {
  255.                     propertyDetails["Visibility"] = ((String) propertyDetails["Visibility"]) + " static";
  256.                 }
  257.                         
  258.             propertyDetails["Access"] = "[ Set ]" ;
  259.                       
  260.                 System.Reflection.ParameterInfo[] paramInfos = propertyInfos[x].GetSetMethod().GetParameters();
  261.                 
  262.                 if (paramInfos != null)
  263.                 {
  264.                     ArrayList paramTable = new ArrayList();
  265.                  
  266.                     for (int y=0; y<paramInfos.Length; y++)
  267.                     {     
  268.                         Hashtable paramDetails = new Hashtable();
  269.                         paramDetails["ParamName"] = paramInfos[y].Name;
  270.                         paramDetails["ParamType"] = paramInfos[y].ParameterType.Name;    
  271.                         if(( paramInfos[y].ParameterType.IsArray && paramInfos[y].ParameterType.Name !="Array") || paramInfos[y].ParameterType.IsPointer) 
  272.                         {
  273.                             paramDetails["GetType"]   = paramInfos[y].ParameterType.GetElementType().Name ;
  274.                             paramDetails["Namespace"] = paramInfos[y].ParameterType.GetElementType().Namespace ;
  275.                         }
  276.                         else  
  277.                         {
  278.                         paramDetails["GetType"]   = paramInfos[y].ParameterType.Name;
  279.                             paramDetails["Namespace"] = paramInfos[y].ParameterType.Namespace ;
  280.                         }
  281.                         paramTable.Add(paramDetails); 
  282.                     }
  283.                  
  284.                     propertyDetails["Params"] = paramTable;
  285.                }
  286.             }
  287.           
  288.            this.Add(propertyDetails);
  289.            
  290.         }
  291.         this.Sort();
  292.     }
  293. }        
  294.  
  295.  
  296. public class DisplayMethods : ArrayList
  297. {    
  298.      public DisplayMethods(Type classType, String myclassname)
  299.      { 
  300.          System.Reflection.MethodInfo[] methodInfos = classType.GetMethods(BindingFlags.Default) ;
  301.           
  302.          if (methodInfos == null)
  303.              return;
  304.                
  305.          for (int x=0; x<methodInfos.Length; x++) 
  306.          {
  307.              if((String.Compare(myclassname,methodInfos[x].DeclaringType.Name )==0)&&(methodInfos[x].IsPublic || methodInfos[x].IsFamily) && (!(methodInfos[x].IsSpecialName)) ) 
  308.              { 
  309.                  SortTable MethodDetails = new SortTable("Name");
  310.  
  311.                  MethodDetails["Name"] = methodInfos[x].Name;
  312.                  MethodDetails["Type"] = methodInfos[x].ReturnType.Name;
  313.                  if(( methodInfos[x].ReturnType.IsArray && methodInfos[x].ReturnType.Name !="Array") ||  methodInfos[x].ReturnType.IsPointer)  
  314.                  {
  315.                      // For Supporting Multi-Dimension Arrays as Return Type 
  316.                      Type ReturnElementType =  methodInfos[x].ReturnType.GetElementType();
  317.                      while(ReturnElementType.IsArray)
  318.                      {
  319.                         ReturnElementType =  ReturnElementType.GetElementType();    
  320.                      }
  321.  
  322.                      MethodDetails["GetType"]   = ReturnElementType.Name ;
  323.                      MethodDetails["Namespace"] = ReturnElementType.Namespace ;
  324.                       
  325.                  }
  326.                  else  
  327.                  {
  328.                  
  329.                   MethodDetails["GetType"] = methodInfos[x].ReturnType.Name;
  330.                       MethodDetails["Namespace"] = methodInfos[x].ReturnType.Namespace ;
  331.                  }             
  332.                 
  333.                  if (methodInfos[x].IsPublic == true) 
  334.                  {
  335.                      MethodDetails["Access"] = "public ";
  336.                  }
  337.                  else if (methodInfos[x].IsPrivate == true) 
  338.                  {
  339.                      MethodDetails["Access"] = "private ";
  340.                  }     
  341.                  else if (methodInfos[x].IsFamily == true) 
  342.                  {
  343.                      MethodDetails["Access"] = "protected ";
  344.                  }    
  345.                  
  346.                  if (methodInfos[x].IsStatic == true) 
  347.                  {
  348.                      MethodDetails["Access"] = ((String) MethodDetails["Access"]) + "static ";
  349.                  }
  350.  
  351.                  System.Reflection.ParameterInfo[] paramInfos = methodInfos[x].GetParameters();
  352.  
  353.                  if (paramInfos != null)
  354.                  {
  355.                   
  356.                      ArrayList paramTable = new ArrayList();
  357.                  
  358.                      for (int y=0; y<paramInfos.Length; y++)
  359.                      {     
  360.                          Hashtable paramDetails = new Hashtable();
  361.                          paramDetails["ParamName"] = paramInfos[y].Name;
  362.                          paramDetails["ParamType"] = paramInfos[y].ParameterType.Name;
  363.                          if(( paramInfos[y].ParameterType.IsArray && paramInfos[y].ParameterType.Name != "Array" )  || paramInfos[y].ParameterType.IsPointer)
  364.                          {
  365.                              paramDetails["GetType"]   = paramInfos[y].ParameterType.GetElementType().Name ;
  366.                              paramDetails["Namespace"] = paramInfos[y].ParameterType.GetElementType().Namespace ;
  367.                          }
  368.                          else  
  369.                          {
  370.                          paramDetails["GetType"]   = paramInfos[y].ParameterType.Name;
  371.                              paramDetails["Namespace"] = paramInfos[y].ParameterType.Namespace ;
  372.                          }
  373.                          paramTable.Add(paramDetails);
  374.                      }
  375.                      
  376.                      MethodDetails["Params"] = paramTable;
  377.                  }
  378.  
  379.                 this.Add(MethodDetails);
  380.              }
  381.         }
  382.          this.Sort();
  383.     }
  384. } 
  385.  
  386. public class DisplayInterfaces : ArrayList
  387. {
  388.     public DisplayInterfaces(Type classType)
  389.     {
  390.          Type[] classInterfaces = classType.GetInterfaces();
  391.          for(int x = 0 ; x < classInterfaces.Length ; x++)
  392.          {
  393.             
  394.             Hashtable interfaceDetails = new Hashtable();
  395.  
  396.             interfaceDetails["FullName"]     = classInterfaces[x].FullName;
  397.             interfaceDetails["GetType"]      = classInterfaces[x].Name;
  398.             interfaceDetails["Namespace"]    = classInterfaces[x].Namespace;
  399.             this.Add(interfaceDetails);
  400.          }
  401.          
  402.      }
  403. }
  404.  
  405.  
  406. public class DisplaySuperclasses : ArrayList
  407. {
  408.     public DisplaySuperclasses(Type classType)
  409.     {
  410.        Type SuperClass ;
  411.  
  412.        Hashtable classDetails = new Hashtable();
  413.  
  414.        classDetails["FullName"]     = classType.FullName;
  415.        classDetails["GetType"]      = classType.Name;
  416.        classDetails["Namespace"]    = classType.Namespace;
  417.  
  418.        this.Add(classDetails);
  419.  
  420.        while (classType.BaseType != null)
  421.        {
  422.            Hashtable superclassDetails = new Hashtable();
  423.            SuperClass =  classType.BaseType ;
  424.            classType   =  SuperClass        ;
  425.  
  426.            superclassDetails["FullName"]     = SuperClass.FullName;
  427.            superclassDetails["GetType"]      = SuperClass.Name;
  428.            superclassDetails["Namespace"]    = SuperClass.Namespace;
  429.  
  430.            this.Add(superclassDetails)    ;
  431.        }
  432.        this.Reverse() ;
  433.     }
  434.    
  435. }
  436.  
  437. public class DisplaySubClasses : ArrayList 
  438. {
  439.      private Type        classType ;
  440.      private Module[]      CorRuntime ;
  441.      private Type[]      CorClasses;
  442.      private String      myclassname ;
  443.      private Type[]      classInterfaces; 
  444.  
  445.  
  446.     
  447.     public DisplaySubClasses(Type classtype,ArrayList ModuleName)
  448.     {
  449.         this.classType =classtype ;
  450.         myclassname = classType.FullName ;
  451.         if (classType.IsInterface ) 
  452.         {
  453.             for(int y = 0 ; y <  ModuleName.Count ;y++)
  454.             {
  455.                 
  456.                 CorRuntime = Assembly.Load(ModuleName[y].ToString()).GetModules(); //System.Assembly.Load(ModuleName[y].ToString()).GetModules();
  457.             CorClasses   = CorRuntime[0].GetTypes() ;
  458.                                    
  459.                 for(int x= 0 ; x < CorClasses.Length; x++)
  460.                 {
  461.                     classType       =  CorClasses[x];
  462.                     classInterfaces =  classType.GetInterfaces() ;
  463.                 
  464.                     for(int  i = 0 ; i < classInterfaces.Length ; i++)
  465.             {
  466.                         if(String.Compare(myclassname , classInterfaces[i].FullName )==0)
  467.                         {
  468.  
  469.                              SortTable subclassDetails     = new SortTable("FullName");
  470.                              subclassDetails["FullName"]     = classType.FullName;
  471.                              subclassDetails["GetType"]      = classType.Name;
  472.                              subclassDetails["Namespace"]    = classType.Namespace;
  473.                   this.Add(subclassDetails) ;      
  474.                 }
  475.                     }
  476.                 }
  477.             }
  478.         }                  
  479.          
  480.         else 
  481.         {
  482.             for(int y = 0; y < ModuleName.Count ; y++)  
  483.             {
  484.                 CorRuntime = Assembly.Load(ModuleName[y].ToString()).GetModules() ;
  485.              CorClasses  = CorRuntime[0].GetTypes() ;
  486.  
  487.                 for( int x= 0 ; x< CorClasses.Length ;x++)
  488.                 {
  489.                     classType = CorClasses[x].BaseType ;
  490.  
  491.                     if ( null != classType  )  
  492.                     {
  493.                         if( String.Compare(classType.FullName, myclassname)==0)
  494.                         {
  495.                             SortTable subclassDetails     = new SortTable("FullName");
  496.                             subclassDetails["FullName"]     = CorClasses[x].FullName;
  497.                             subclassDetails["GetType"]      = CorClasses[x].Name;
  498.                             subclassDetails["Namespace"]    = CorClasses[x].Namespace;
  499.                  this.Add(subclassDetails) ;      
  500.                         }      
  501.                     }
  502.                 }
  503.             }
  504.         }
  505.         this.Sort();
  506.     }
  507. }
  508.  
  509.  
  510. }
  511.  
  512.  
  513.