Tools/ManagedExtensions/ManagementExtensions/Default/MInspector.cs

   1 // Copyright 2003-2004 DigitalCraftsmen - http://www.digitalcraftsmen.com.br/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.ManagementExtensions.Default
  16 {
  17         using System;
  18         using System.Reflection;
  19
  20         public enum ComponentType
  21         {
  22                 None,
  23                 Standard,
  24                 Dynamic
  25         }
  26
  27         /// <summary>
  28         /// Summary description for MInspector.
  29         /// </summary>
  30         public class MInspector
  31         {
  32                 private MInspector()
  33                 {
  34                 }
  35
  36                 /// <summary>
  37                 /// TODO: Summary
  38                 /// </summary>
  39                 /// <param name="instance"></param>
  40                 /// <returns></returns>
  41                 public static ComponentType Inspect(Object instance)
  42                 {
  43                         return Inspect( instance.GetType() );
  44                 }
  45
  46                 public static ComponentType Inspect(Type target)
  47                 {
  48                         if (typeof(MDynamicSupport).IsAssignableFrom(target))
  49                         {
  50                                 return ComponentType.Dynamic;
  51                         }
  52                         else
  53                         {
  54                                 if (target.IsDefined( typeof(ManagedComponentAttribute), true ))
  55                                 {
  56                                         return ComponentType.Standard;
  57                                 }
  58                         }
  59
  60                         return ComponentType.None;
  61                 }
  62
  63                 /// <summary>
  64                 /// TODO: Summary
  65                 /// </summary>
  66                 /// <param name="instance"></param>
  67                 /// <returns></returns>
  68                 public static ManagementInfo BuildInfoFromStandardComponent(Object instance)
  69                 {
  70                         ManagementInfo info = new ManagementInfo();
  71
  72                         SetupManagedComponent(info, instance);
  73                         SetupManagedOperations(info, instance);
  74                         SetupManagedAttributes(info, instance);
  75
  76                         return info;
  77                 }
  78
  79                 private static void SetupManagedComponent(ManagementInfo info, Object instance)
  80                 {
  81                         Object[] componentAtt =
  82                                 instance.GetType().GetCustomAttributes(
  83                                         typeof(ManagedComponentAttribute), true );
  84
  85                         if (componentAtt == null || componentAtt.Length == 0)
  86                         {
  87                                 throw new StandardComponentException("Standard component must use ManagedComponentAttribute attribute.");
  88                         }
  89
  90                         ManagedComponentAttribute compAtt = componentAtt[0] as ManagedComponentAttribute;
  91
  92                         info.Description = compAtt.Description;
  93                 }
  94
  95                 private static void SetupManagedOperations(ManagementInfo info, Object instance)
  96                 {
  97                         MethodInfo[] methods = instance.GetType().GetMethods(BindingFlags.Public|BindingFlags.Instance);
  98
  99                         foreach(MethodInfo minfo in methods)
 100                         {
 101                                 if (minfo.IsDefined( typeof(ManagedOperationAttribute), true ))
 102                                 {
 103                                         object[] atts = minfo.GetCustomAttributes( typeof(ManagedOperationAttribute), true );
 104
 105                                         ManagedOperationAttribute att = (ManagedOperationAttribute) atts[0];
 106
 107                                         ParameterInfo[] parameters = minfo.GetParameters();
 108
 109                                         Type[] arguments = new Type[ parameters.Length ];
 110
 111                                         for(int i=0 ; i < parameters.Length; i++ )
 112                                         {
 113                                                 arguments[i] = parameters[i].ParameterType;
 114                                         }
 115
 116                                         ManagementOperation operation = new ManagementOperation(minfo.Name, att.Description, arguments);
 117
 118                                         info.Operations.Add(operation);
 119                                 }
 120                         }
 121                 }
 122
 123                 private static void SetupManagedAttributes(ManagementInfo info, Object instance)
 124                 {
 125                         PropertyInfo[] properties = instance.GetType().GetProperties(BindingFlags.Public|BindingFlags.Instance);
 126
 127                         foreach(PropertyInfo minfo in properties)
 128                         {
 129                                 if (minfo.IsDefined( typeof(ManagedAttributeAttribute), true ))
 130                                 {
 131                                         object[] atts = minfo.GetCustomAttributes( typeof(ManagedAttributeAttribute), true );
 132
 133                                         ManagedAttributeAttribute att = (ManagedAttributeAttribute) atts[0];
 134
 135                                         ManagementAttribute attribute = new ManagementAttribute(minfo.Name, att.Description, minfo.PropertyType);
 136
 137                                         info.Attributes.Add(attribute);
 138                                 }
 139                         }
 140                 }
 141         }
 142 }