Tools/DynamicProxy/Castle.DynamicProxy/Builder/CodeGenerators/ModuleScope.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.Builder.CodeGenerators
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Reflection;
  20         using System.Reflection.Emit;
  21         using System.Collections;
  22         using System.Threading;
  23
  24         /// <summary>
  25         /// Summary description for ModuleScope.
  26         /// </summary>
  27         [CLSCompliant(false)]
  28         public class ModuleScope
  29         {
  30                 public static readonly String FILE_NAME = "GeneratedAssembly.dll";
  31                 public static readonly String ASSEMBLY_NAME = "DynamicAssemblyProxyGen";
  32
  33                 /// <summary>
  34                 /// Avoid leaks caused by non disposal of generated types.
  35                 /// </summary>
  36                 private ModuleBuilder _moduleBuilderWithStrongName = null;
  37         private ModuleBuilder _moduleBuilder = null;
  38
  39                 /// <summary>
  40                 /// Keep track of generated types
  41                 /// </summary>
  42                 private Hashtable _typeCache = Hashtable.Synchronized(new Hashtable());
  43
  44                 /// <summary>
  45                 /// Used to lock the module builder creation
  46                 /// </summary>
  47                 private object _lockobj = new object();
  48
  49                 private ReaderWriterLock readerWriterLock = new ReaderWriterLock();
  50
  51                 private AssemblyBuilder _assemblyBuilder;
  52
  53             public ModuleBuilder ObtainDynamicModule()
  54             {
  55             return ObtainDynamicModule(false);
  56             }
  57
  58                 public ModuleBuilder ObtainDynamicModule(bool signStrongName)
  59                 {
  60                         lock (_lockobj)
  61                         {
  62                 if (signStrongName && _moduleBuilderWithStrongName == null)
  63                                 {
  64                     _moduleBuilderWithStrongName =  CreateModule(signStrongName);
  65                                 }
  66                             else if(!signStrongName && _moduleBuilder == null)
  67                             {
  68                     _moduleBuilder = CreateModule(signStrongName);
  69                             }
  70                         }
  71             return signStrongName ? _moduleBuilderWithStrongName : _moduleBuilder;
  72                 }
  73
  74             private ModuleBuilder CreateModule(bool signStrongName)
  75             {
  76                 AssemblyName assemblyName = new AssemblyName();
  77                 assemblyName.Name = ASSEMBLY_NAME;
  78                 if (signStrongName)
  79                 {
  80                     assemblyName.KeyPair = new StrongNameKeyPair(GetKeyPair());
  81                 }
  82 #if ( PHYSICALASSEMBLY )
  83                         _assemblyBuilder =
  84                                 AppDomain.CurrentDomain.DefineDynamicAssembly(
  85                                         assemblyName,
  86                                         AssemblyBuilderAccess.RunAndSave);
  87                         _moduleBuilder = _assemblyBuilder.DefineDynamicModule(assemblyName.Name, FILE_NAME);
  88 #else
  89                         _assemblyBuilder =
  90                                 AppDomain.CurrentDomain.DefineDynamicAssembly(
  91                                         assemblyName,
  92                                         AssemblyBuilderAccess.Run);
  93                         return _assemblyBuilder.DefineDynamicModule(assemblyName.Name, true);
  94 #endif
  95             }
  96
  97             public ReaderWriterLock RWLock
  98                 {
  99                         get { return readerWriterLock; }
 100                 }
 101
 102                 public void SaveAssembly()
 103                 {
 104 #if ( PHYSICALASSEMBLY )
 105                         _assemblyBuilder.Save(FILE_NAME);
 106 #endif
 107                 }
 108
 109                 public Type this[String name]
 110                 {
 111                         get { return _typeCache[name] as Type; }
 112                         set
 113                         {
 114                                 _typeCache[name] = value;
 115                                 SaveAssembly();
 116                         }
 117                 }
 118
 119         private static byte[] GetKeyPair()
 120         {
 121             byte[] keyPair;
 122             using(Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("Castle.DynamicProxy.DynProxy.snk"))
 123             {
 124                 int length = (int)stream.Length;
 125                 keyPair = new byte[length];
 126                 stream.Read(keyPair, 0, length);
 127             }
 128             return keyPair;
 129         }
 130         }
 131 }