Tools/ManagedExtensions/ManagementExtensions/Default/Strategy/ReflectionInvokerStrategy.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.Strategy
  16 {
  17         using System;
  18         using System.Text;
  19         using System.Collections;
  20         using System.Reflection;
  21
  22         /// <summary>
  23         /// Summary description for ReflectionInvokerStrategy.
  24         /// </summary>
  25         public class ReflectionInvokerStrategy : InvokerStrategy
  26         {
  27                 public ReflectionInvokerStrategy()
  28                 {
  29                 }
  30
  31                 #region InvokerStrategy Members
  32
  33                 public MDynamicSupport Create(Object instance)
  34                 {
  35                         ManagementInfo info = MInspector.BuildInfoFromStandardComponent(instance);
  36
  37                         return new ReflectedDynamicSupport(
  38                                 instance, info,
  39                                 new MemberResolver(info, instance.GetType()));
  40                 }
  41
  42                 #endregion
  43         }
  44
  45         /// <summary>
  46         ///
  47         /// </summary>
  48         class ReflectedDynamicSupport : MDynamicSupport
  49         {
  50                 private Object instance;
  51                 private ManagementInfo info;
  52                 private MemberResolver resolver;
  53
  54                 public ReflectedDynamicSupport(Object instance, ManagementInfo info, MemberResolver resolver)
  55                 {
  56                         this.info     = info;
  57                         this.instance = instance;
  58                         this.resolver = resolver;
  59                 }
  60
  61                 #region MDynamicSupport Members
  62
  63                 /// <summary>
  64                 /// TODO: Summary
  65                 /// </summary>
  66                 /// <param name="action"></param>
  67                 /// <param name="args"></param>
  68                 /// <param name="signature"></param>
  69                 /// <returns></returns>
  70                 public Object Invoke(String action, Object[] args, Type[] signature)
  71                 {
  72                         if (action == null)
  73                         {
  74                                 throw new ArgumentNullException("action");
  75                         }
  76
  77                         ManagementOperation operation = (ManagementOperation) info.Operations[action];
  78
  79                         if (operation == null)
  80                         {
  81                                 throw new InvalidOperationException(String.Format("Operation {0} doesn't exists.", action));
  82                         }
  83
  84                         MethodInfo method = resolver.GetMethod(MemberResolver.BuildOperationName(action, signature));
  85
  86                         if (method == null)
  87                         {
  88                                 foreach(MethodInfo met in resolver.Methods)
  89                                 {
  90                                         if (!met.Name.Equals( operation.Name ))
  91                                         {
  92                                                 continue;
  93                                         }
  94
  95                                         ParameterInfo[] parameters = met.GetParameters();
  96
  97                                         if (MemberResolver.Match(parameters, signature))
  98                                         {
  99                                                 method = met;
 100                                                 break;
 101                                         }
 102                                 }
 103                         }
 104
 105                         if (method == null)
 106                         {
 107                                 throw new InvalidOperationException(String.Format("Operation {0} doesn't exists for the specified signature.", action));
 108                         }
 109
 110                         return method.Invoke(instance, args);
 111                 }
 112
 113                 /// <summary>
 114                 /// TODO: Summary
 115                 /// </summary>
 116                 /// <param name="name"></param>
 117                 /// <returns></returns>
 118                 public Object GetAttributeValue(String name)
 119                 {
 120                         if (name == null)
 121                         {
 122                                 throw new ArgumentNullException("name");
 123                         }
 124
 125                         ManagementAttribute attribute = (ManagementAttribute) info.Attributes[name];
 126
 127                         if (attribute == null)
 128                         {
 129                                 throw new InvalidOperationException(String.Format("Attribute {0} doesn't exists.", name));
 130                         }
 131
 132                         PropertyInfo property = resolver.GetProperty(attribute.Name);
 133
 134                         if (!property.CanRead)
 135                         {
 136                                 throw new InvalidOperationException(String.Format("Attribute {0} can't be read.", name));
 137                         }
 138
 139                         MethodInfo getMethod = property.GetGetMethod();
 140
 141                         return getMethod.Invoke(instance, null);
 142                 }
 143
 144                 /// <summary>
 145                 /// TODO: Summary
 146                 /// </summary>
 147                 /// <param name="name"></param>
 148                 /// <param name="value"></param>
 149                 public void SetAttributeValue(String name, Object value)
 150                 {
 151                         if (name == null)
 152                         {
 153                                 throw new ArgumentNullException("name");
 154                         }
 155
 156                         ManagementAttribute attribute = (ManagementAttribute) info.Attributes[name];
 157
 158                         if (attribute == null)
 159                         {
 160                                 throw new InvalidOperationException(String.Format("Attribute {0} doesn't exists.", name));
 161                         }
 162
 163                         PropertyInfo property = resolver.GetProperty(attribute.Name);
 164
 165                         if (!property.CanWrite)
 166                         {
 167                                 throw new InvalidOperationException(String.Format("Attribute {0} is read-only.", name));
 168                         }
 169
 170                         MethodInfo setMethod = property.GetSetMethod();
 171
 172                         setMethod.Invoke(instance, new object[] { value } );
 173                 }
 174
 175                 /// <summary>
 176                 /// TODO: Summary
 177                 /// </summary>
 178                 public ManagementInfo Info
 179                 {
 180                         get
 181                         {
 182                                 return info;
 183                         }
 184                 }
 185
 186                 #endregion
 187         }
 188 }