Tools/Castle.DynamicProxy2/Castle.DynamicProxy/InternalsHelper.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.DynamicProxy
  16 {
  17         using System.Collections.Generic;
  18         using System.Reflection;
  19         using System.Runtime.CompilerServices;
  20         using System.Threading;
  21
  22         public class InternalsHelper
  23         {
  24                 private static ReaderWriterLock internalsToDynProxyLock = new ReaderWriterLock();
  25                 private static IDictionary<Assembly, bool> internalsToDynProxy = new Dictionary<Assembly, bool>();
  26
  27                 /// <summary>
  28                 /// Determines whether this assembly has internals visisble to dynamic proxy.
  29                 /// </summary>
  30                 /// <param name="asm">The asm.</param>
  31                 public static bool IsInternalToDynamicProxy(Assembly asm)
  32                 {
  33                         internalsToDynProxyLock.AcquireReaderLock(-1);
  34
  35                         if (internalsToDynProxy.ContainsKey(asm))
  36                         {
  37                                 internalsToDynProxyLock.ReleaseReaderLock();
  38
  39                                 return internalsToDynProxy[asm];
  40                         }
  41
  42                         internalsToDynProxyLock.UpgradeToWriterLock(-1);
  43
  44                         try
  45                         {
  46                                 if (internalsToDynProxy.ContainsKey(asm))
  47                                 {
  48                                         return internalsToDynProxy[asm];
  49                                 }
  50
  51                                 InternalsVisibleToAttribute[] atts = (InternalsVisibleToAttribute[])
  52                                                                      asm.GetCustomAttributes(typeof(InternalsVisibleToAttribute), false);
  53
  54                                 bool found = false;
  55
  56                                 foreach(InternalsVisibleToAttribute internals in atts)
  57                                 {
  58                                         if (internals.AssemblyName.Contains(ModuleScope.DEFAULT_ASSEMBLY_NAME))
  59                                         {
  60                                                 found = true;
  61                                                 break;
  62                                         }
  63                                 }
  64
  65                                 internalsToDynProxy.Add(asm, found);
  66
  67                                 return found;
  68                         }
  69                         finally
  70                         {
  71                                 internalsToDynProxyLock.ReleaseWriterLock();
  72                         }
  73                 }
  74
  75                 /// <summary>
  76                 /// Determines whether the specified method is internal.
  77                 /// </summary>
  78                 /// <param name="method">The method.</param>
  79                 /// <returns>
  80                 ///     <c>true</c> if the specified method is internal; otherwise, <c>false</c>.
  81                 /// </returns>
  82                 public static bool IsInternal(MethodInfo method)
  83                 {
  84                         return method.IsAssembly || (method.IsFamilyAndAssembly
  85                                                      && !method.IsFamilyOrAssembly);
  86                 }
  87         }
  88 }