Samples/InversionOfControl/AnotherExtendingSample/TransactionFacility.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 Extending2
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Reflection;
  20
  21         using Extending2.Components;
  22
  23         using Castle.Core;
  24         using Castle.Core.Configuration;
  25
  26         using Castle.MicroKernel;
  27
  28         /// <summary>
  29         /// Summary description for TransactionFacility.
  30         /// </summary>
  31         public class TransactionFacility : IFacility
  32         {
  33                 TransactionConfigHolder _transactionConfigHolder;
  34
  35                 public void Init(IKernel kernel, IConfiguration facilityConfig)
  36                 {
  37                         kernel.AddComponent( "transactionmanager",
  38                                 typeof(ITransactionManager), typeof(DefaultTransactionManager) );
  39                         kernel.AddComponent( "transaction.interceptor",
  40                                 typeof(TransactionInterceptor) );
  41                         kernel.AddComponent( "transaction.configholder", typeof(TransactionConfigHolder) );
  42
  43                         _transactionConfigHolder =
  44                                 kernel[ typeof(TransactionConfigHolder) ] as TransactionConfigHolder;
  45
  46                         kernel.ComponentModelCreated += new ComponentModelDelegate(OnModelCreated);
  47                 }
  48
  49                 public void Terminate()
  50                 {
  51                 }
  52
  53                 private void OnModelCreated(ComponentModel model)
  54                 {
  55                         if (IsTransactional(model))
  56                         {
  57                                 TransactionConfig config = CreateTransactionConfig(model);
  58
  59                                 _transactionConfigHolder.Register(model.Implementation, config);
  60
  61                                 model.Interceptors.Add(
  62                                         new InterceptorReference(typeof(TransactionInterceptor)) );
  63                         }
  64                 }
  65
  66                 private TransactionConfig CreateTransactionConfig(ComponentModel model)
  67                 {
  68                         TransactionConfig config = new TransactionConfig();
  69                         GatherTransactionAttributes(config, model.Implementation);
  70                         GatherTransactionConfiguration(config, model);
  71                         return config;
  72                 }
  73
  74                 private bool IsTransactional(ComponentModel model)
  75                 {
  76                         if (model.Configuration != null)
  77                         {
  78                                 String attrValue = model.Configuration.Attributes["transactional"];
  79
  80                                 if ("true".Equals(attrValue))
  81                                 {
  82                                         return true;
  83                                 }
  84                         }
  85
  86                         if ( model.Implementation.IsDefined( typeof(TransactionalAttribute), true ) )
  87                         {
  88                                 return true;
  89                         }
  90
  91                         return false;
  92                 }
  93
  94                 private void GatherTransactionConfiguration(TransactionConfig config, ComponentModel model)
  95                 {
  96                         if (model.Configuration == null) return;
  97
  98                         IConfiguration transactionNode = model.Configuration.Children["transaction"];
  99
 100                         if (transactionNode == null) return;
 101
 102                         foreach(IConfiguration methodNode in transactionNode.Children)
 103                         {
 104                                 config.AddMethodName( methodNode.Value );
 105                         }
 106                 }
 107
 108                 private void GatherTransactionAttributes(TransactionConfig config, Type implementation)
 109                 {
 110                         MethodInfo[] methods = implementation.GetMethods(
 111                                 BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic );
 112
 113                         foreach(MethodInfo method in methods)
 114                         {
 115                                 if (method.IsDefined( typeof(RequiresTransactionAttribute), true ))
 116                                 {
 117                                         config.AddMethod( method );
 118                                 }
 119                         }
 120                 }
 121         }
 122
 123
 124         public class TransactionConfig
 125         {
 126                 private IList _methods = new ArrayList();
 127                 private IList _methodName = new ArrayList();
 128
 129                 public void AddMethodName(string value)
 130                 {
 131                         _methodName.Add(value);
 132                 }
 133
 134                 public void AddMethod(MethodInfo method)
 135                 {
 136                         _methods.Add(method);
 137                 }
 138
 139                 /// <summary>
 140                 /// A
 141                 /// </summary>
 142                 /// <param name="method"></param>
 143                 /// <returns></returns>
 144                 public bool IsMethodTransactional(MethodInfo method)
 145                 {
 146                         if (_methods.Contains(method)) return true;
 147
 148                         foreach(String methodName in _methodName)
 149                         {
 150                                 if (method.Name.Equals(methodName))
 151                                 {
 152                                         return true;
 153                                 }
 154                         }
 155
 156                         return false;
 157                 }
 158         }
 159 }