Components/DictionaryAdapter/Castle.Components.DictionaryAdapter/Attributes/AttributesUtil.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.Components.DictionaryAdapter
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.Reflection;
  20
  21         /// <summary>
  22         /// Helper class for retrieving attributes.
  23         /// </summary>
  24         public static class AttributesUtil
  25         {
  26                 /// <summary>
  27                 /// Gets the type attribute.
  28                 /// </summary>
  29                 /// <param name="type">The type.</param>
  30                 /// <returns>The type attribute.</returns>
  31                 public static T GetTypeAttribute<T>(Type type) where T : class
  32                 {
  33                         T attribute = GetAttribute<T>(type);
  34
  35                         if (attribute == null)
  36                         {
  37                                 foreach (Type baseInterface in type.GetInterfaces())
  38                                 {
  39                                         attribute = GetTypeAttribute<T>(baseInterface);
  40                                         if (attribute != null)
  41                                         {
  42                                                 break;
  43                                         }
  44                                 }
  45                         }
  46
  47                         return attribute;
  48                 }
  49
  50                 /// <summary>
  51                 /// Gets the attribute.
  52                 /// </summary>
  53                 /// <param name="member">The member.</param>
  54                 /// <returns>The member attribute.</returns>
  55                 public static T GetAttribute<T>(MemberInfo member) where T : class
  56                 {
  57                         object[] attributes = member.GetCustomAttributes(typeof(T), false);
  58                         if (attributes.Length > 0)
  59                         {
  60                                 return (T)attributes[0];
  61                         }
  62                         return null;
  63                 }
  64
  65                 /// <summary>
  66                 /// Gets the type attributes.
  67                 /// </summary>
  68                 /// <param name="type">The type.</param>
  69                 /// <returns>The type attributes.</returns>
  70                 public static List<T> GetTypeAttributes<T>(Type type)
  71                 {
  72                         List<T> attributes = GetAttributes<T>(type);
  73
  74                         if (attributes == null)
  75                         {
  76                                 foreach (Type baseInterface in type.GetInterfaces())
  77                                 {
  78                                         attributes = GetTypeAttributes<T>(baseInterface);
  79                                         if (attributes != null)
  80                                         {
  81                                                 break;
  82                                         }
  83                                 }
  84                         }
  85
  86                         return attributes;
  87                 }
  88
  89                 /// <summary>
  90                 /// Gets the attributes.
  91                 /// </summary>
  92                 /// <param name="member">The member.</param>
  93                 /// <returns>The member attributes.</returns>
  94                 public static List<T> GetAttributes<T>(MemberInfo member)
  95                 {
  96                         List<T> attributes = null;
  97                         object[] custom = member.GetCustomAttributes(typeof(T), false);
  98
  99                         if (custom.Length > 0)
 100                         {
 101                                 attributes = new List<T>();
 102                                 foreach (T builder in custom)
 103                                 {
 104                                         attributes.Add(builder);
 105                                 }
 106                         }
 107
 108                         return attributes;
 109                 }
 110         }
 111 }