Facilities/BatchRegistration/Castle.Facilities.BatchRegistration/ComponentScanner.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   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.Facilities.BatchRegistration
  16 {
  17         using System;
  18         using System.Reflection;
  19         using System.Collections;
  20         using System.Configuration;
  21
  22         using Castle.Core;
  23
  24
  25         public sealed class ComponentScanner
  26         {
  27                 private bool _useAttributes;
  28                 private String _assemblyName;
  29                 private ArrayList _includes;
  30                 private ArrayList _excludes;
  31                 private ArrayList _result;
  32
  33                 public ComponentScanner(String assemblyName)
  34                 {
  35                         _includes = new ArrayList();
  36                         _excludes = new ArrayList();
  37                         _result= new ArrayList();
  38                         _assemblyName = assemblyName;
  39                 }
  40
  41                 public bool UseAttributes
  42                 {
  43                         get { return _useAttributes; }
  44                         set { _useAttributes = value; }
  45                 }
  46
  47                 public void AddInclude(String key, String service, String className)
  48                 {
  49                         if (key == null) throw new ArgumentNullException("key");
  50                         if (className == null) throw new ArgumentNullException("className");
  51
  52                         _includes.Add(new ComponentDefinition(key, service, className));
  53                 }
  54
  55                 public void AddExclude(String className)
  56                 {
  57                         if (className == null) throw new ArgumentNullException("className");
  58
  59                         _excludes.Add(className);
  60                 }
  61
  62                 public ComponentDefinition[] Process()
  63                 {
  64                         Assembly assembly = LoadAssembly();
  65
  66                         SortExcludes();
  67
  68                         InspectTypes(assembly);
  69
  70                         ProcessIncludes(assembly);
  71
  72                         return (ComponentDefinition[]) _result.ToArray( typeof(ComponentDefinition) );
  73                 }
  74
  75                 private void InspectTypes(Assembly assembly)
  76                 {
  77                         if (_useAttributes)
  78                         {
  79                                 foreach(Type type in assembly.GetExportedTypes())
  80                                 {
  81                                         ProcessType(type);
  82                                 }
  83                         }
  84                 }
  85
  86                 private Assembly LoadAssembly()
  87                 {
  88                         try
  89                         {
  90                                 return Assembly.Load(_assemblyName);
  91                         }
  92                         catch(Exception ex)
  93                         {
  94                                 String message =
  95                                         String.Format("Could not load the specified assembly {0}", _assemblyName);
  96
  97                                 throw new ConfigurationErrorsException(message, ex);
  98                         }
  99                 }
 100
 101                 private void ProcessIncludes(Assembly assembly)
 102                 {
 103                         foreach(ComponentDefinition def in _includes)
 104                         {
 105                                 if (_excludes.BinarySearch( def.ClassName ) == -1)
 106                                 {
 107                                         AddToResult( assembly, def );
 108                                 }
 109                         }
 110                 }
 111
 112                 private void SortExcludes()
 113                 {
 114                         _excludes.Sort( CaseInsensitiveComparer.Default );
 115                 }
 116
 117                 private void ProcessType(Type type)
 118                 {
 119                         if (type.IsDefined( typeof(CastleComponentAttribute), false ))
 120                         {
 121                                 if (_excludes.BinarySearch( type.FullName ) == -1)
 122                                 {
 123                                         CastleComponentAttribute attribute = (CastleComponentAttribute)
 124                                                 type.GetCustomAttributes( typeof(CastleComponentAttribute), false )[0];
 125
 126                                         AddToResult( type, attribute );
 127                                 }
 128                         }
 129                 }
 130
 131                 private void AddToResult(Assembly assembly, ComponentDefinition def)
 132                 {
 133                         _result.Add( new ComponentDefinition(
 134                                 def.Key,
 135                                 ObtainType(assembly, def.Service),
 136                                 InferType(assembly, def.ClassName) ) );
 137                 }
 138
 139                 private void AddToResult(Type type, CastleComponentAttribute attribute)
 140                 {
 141                         _result.Add( new ComponentDefinition( attribute.Key, attribute.Service, type ) );
 142                 }
 143
 144                 /// <summary>
 145                 /// This method always tries to obtain the type
 146                 /// from the specified assembly.
 147                 /// </summary>
 148                 /// <param name="typeName"></param>
 149                 /// <param name="assembly"></param>
 150                 /// <returns></returns>
 151                 private Type InferType(Assembly assembly, String typeName)
 152                 {
 153                         return TypeLoadUtil.GetType(assembly, typeName);
 154                 }
 155
 156                 /// <summary>
 157                 /// Obtains the <c>Type</c> by checking if the
 158                 /// <c>typeName</c> is possible a full type name, or
 159                 /// just an namespace.typename and for the later case,
 160                 /// it tries to load the type from the specified assembly
 161                 /// </summary>
 162                 /// <param name="assembly"></param>
 163                 /// <param name="typeName"></param>
 164                 /// <returns></returns>
 165                 private Type ObtainType(Assembly assembly, String typeName)
 166                 {
 167                         if (typeName == null) return null;
 168
 169                         if (typeName.IndexOf(',') == -1)
 170                         {
 171                                 return InferType(assembly, typeName);
 172                         }
 173                         else
 174                         {
 175                                 return TypeLoadUtil.GetType(typeName);
 176                         }
 177                 }
 178         }
 179 }