MonoRail/Castle.MonoRail.Framework/Services/DefaultViewComponentFactory.cs

   1 // Copyright 2004-2008 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.MonoRail.Framework.Services
  16 {
  17         using System;
  18         using System.Reflection;
  19         using Castle.Core.Logging;
  20         using Castle.MonoRail.Framework.Configuration;
  21
  22         /// <summary>
  23         /// Default implementation of <see cref="IViewComponentFactory"/>
  24         /// <para>
  25         /// This implementation looks for concrete types that extend
  26         /// <see cref="ViewComponent"/> in an assembly
  27         /// </para>
  28         /// </summary>
  29         public class DefaultViewComponentFactory : AbstractViewComponentFactory
  30         {
  31                 /// <summary>
  32                 /// The logger instance
  33                 /// </summary>
  34                 private ILogger logger = NullLogger.Instance;
  35
  36                 /// <summary>
  37                 /// View engine instance used to initialize the <see cref="ViewComponent"/>
  38                 /// instance upon creation
  39                 /// </summary>
  40                 private IViewEngine viewEngine;
  41
  42                 private String[] assemblies;
  43
  44                 /// <summary>
  45                 /// A dictionary of name to ViewComponent
  46                 /// </summary>
  47                 private IViewComponentRegistry registry;
  48
  49                 /// <summary>
  50                 /// Constructs a <c>DefaultViewComponentFactory</c>
  51                 /// </summary>
  52                 public DefaultViewComponentFactory()
  53                 {
  54                         registry = new DefaultViewComponentRegistry();
  55                 }
  56
  57                 #region IInitializable implementation
  58
  59                 /// <summary>
  60                 /// Invoked by the framework in order to initialize the state
  61                 /// </summary>
  62                 public override void Initialize()
  63                 {
  64                         base.Initialize();
  65
  66                         if (assemblies != null)
  67                         {
  68                                 foreach(String assembly in assemblies)
  69                                 {
  70                                         Inspect(assembly);
  71                                 }
  72                         }
  73
  74                         assemblies = null;
  75                 }
  76
  77                 #endregion
  78
  79                 /// <summary>
  80                 /// Gets the view component registry.
  81                 /// </summary>
  82                 /// <returns></returns>
  83                 protected override IViewComponentRegistry GetViewComponentRegistry()
  84                 {
  85                         return registry;
  86                 }
  87
  88                 /// <summary>
  89                 /// Invoked by the framework in order to give a chance to
  90                 /// obtain other services
  91                 /// </summary>
  92                 /// <param name="provider">The service proviver</param>
  93                 public override void Service(IServiceProvider provider)
  94                 {
  95                         base.Service(provider);
  96
  97                         ILoggerFactory loggerFactory = (ILoggerFactory) provider.GetService(typeof(ILoggerFactory));
  98
  99                         if (loggerFactory != null)
 100                         {
 101                                 logger = loggerFactory.Create(typeof(DefaultViewComponentFactory));
 102                         }
 103
 104                         IMonoRailConfiguration config = (IMonoRailConfiguration) provider.GetService(typeof(IMonoRailConfiguration));
 105
 106                         if (config != null)
 107                         {
 108                                 assemblies = config.ViewComponentsConfig.Assemblies;
 109
 110                                 if (assemblies == null || assemblies.Length == 0)
 111                                 {
 112                                         // Convetion: uses the controller assemblies in this case
 113
 114                                         assemblies = config.ControllersConfig.Assemblies.ToArray();
 115                                 }
 116                         }
 117                 }
 118
 119                 /// <summary>
 120                 /// Loads the assembly and inspect its public types.
 121                 /// </summary>
 122                 /// <param name="assemblyFileName"></param>
 123                 public void Inspect(String assemblyFileName)
 124                 {
 125                         if (logger.IsDebugEnabled)
 126                         {
 127                                 logger.DebugFormat("Inspecting assembly {0}", assemblyFileName);
 128                         }
 129
 130                         Assembly assembly = Assembly.Load(assemblyFileName);
 131
 132                         Inspect(assembly);
 133                 }
 134
 135                 /// <summary>
 136                 /// Inspect the assembly's public types.
 137                 /// </summary>
 138                 public void Inspect(Assembly assembly)
 139                 {
 140                         Type[] types = assembly.GetExportedTypes();
 141
 142                         foreach(Type type in types)
 143                         {
 144                                 if (!type.IsPublic || type.IsAbstract || type.IsInterface || type.IsValueType)
 145                                 {
 146                                         continue;
 147                                 }
 148
 149                                 if (typeof(ViewComponent).IsAssignableFrom(type))
 150                                 {
 151                                         RegisterComponent(type.Name, type);
 152                                 }
 153                         }
 154                 }
 155
 156                 /// <summary>
 157                 /// Implementors should return a reference to
 158                 /// the current view engine.
 159                 /// </summary>
 160                 /// <value></value>
 161                 public override IViewEngine ViewEngine
 162                 {
 163                         get { return viewEngine; }
 164                         set { viewEngine = value; }
 165                 }
 166         }
 167 }