Tools/DynamicProxy/Castle.DynamicProxy/Builder/GeneratorContext.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;
  18     using System.Reflection;
  19     using System.Collections;
  20     using System.Runtime.Serialization;
  21
  22     using Castle.DynamicProxy.Serialization;
  23     using Castle.DynamicProxy.Invocation;
  24
  25     /// <summary>
  26     /// Summary description for GeneratorContext.
  27     /// </summary>
  28     public sealed class GeneratorContext : DictionaryBase
  29     {
  30         private IList _skipInterfaces = new ArrayList();
  31         private IList _skipMethods = new ArrayList();
  32         private IList _generateNewSlot = new ArrayList();
  33         private ArrayList _mixins = new ArrayList();
  34         private Type _proxyObjectReference = typeof(ProxyObjectReference);
  35         private Type _interceptor = typeof(IInterceptor);
  36         private Type _invocation = typeof(IInvocation);
  37         private Type _interfaceInvocation = typeof(InterfaceInvocation);
  38         private Type _sameClassInvocation = typeof(SameClassInvocation);
  39
  40         public GeneratorContext()
  41         {
  42             // By default we skip a few interfaces
  43             AddInterfaceToSkip(typeof(ISerializable));
  44
  45             // And their methods
  46             AddMethodToSkip(typeof(ISerializable).GetMethod("GetObjectData"));
  47         }
  48
  49         /// <summary>
  50         /// The implementor of IObjectReference responsible for
  51         /// the deserialization and reconstruction of the proxy object
  52         /// </summary>
  53         public Type ProxyObjectReference
  54         {
  55             get { return _proxyObjectReference; }
  56             set { _proxyObjectReference = value; }
  57         }
  58
  59         public Type Interceptor
  60         {
  61             get { return _interceptor; }
  62             set { _interceptor = value; }
  63         }
  64
  65         public Type Invocation
  66         {
  67             get { return _invocation; }
  68             set { _invocation = value; }
  69         }
  70
  71         public Type InterfaceInvocation
  72         {
  73             get { return _interfaceInvocation; }
  74             set { _interfaceInvocation = value; }
  75         }
  76
  77         public Type SameClassInvocation
  78         {
  79             get { return _sameClassInvocation; }
  80             set { _sameClassInvocation = value; }
  81         }
  82
  83         public bool HasMixins
  84         {
  85             get { return _mixins.Count != 0; }
  86         }
  87
  88         public void AddMixinInstance(object instance)
  89         {
  90             _mixins.Add(instance);
  91         }
  92
  93         public object[] MixinsAsArray()
  94         {
  95             return _mixins.ToArray();
  96         }
  97
  98         public bool ShouldSkip(Type interfaceType)
  99         {
 100             return _skipInterfaces.Contains(interfaceType);
 101         }
 102
 103         public bool ShouldSkip(MethodInfo method)
 104         {
 105             return _skipMethods.Contains(method);
 106         }
 107
 108         /// <summary>
 109         /// Checks if the method has the same signature as a method that was marked as
 110         /// one that should generate a new vtable slot.
 111         /// </summary>
 112         public bool ShouldCreateNewSlot(MethodInfo method)
 113         {
 114             string methodStr = method.ToString();
 115             foreach (MethodInfo candidate in _generateNewSlot)
 116             {
 117                 if (candidate.ToString() == methodStr)
 118                     return true;
 119             }
 120             return false;
 121         }
 122
 123         public void AddInterfaceToSkip(Type interfaceType)
 124         {
 125             _skipInterfaces.Add(interfaceType);
 126         }
 127
 128         public void AddMethodToSkip(MethodInfo method)
 129         {
 130             _skipMethods.Add(method);
 131         }
 132
 133         public void AddMethodToGenerateNewSlot(MethodInfo method)
 134         {
 135             _generateNewSlot.Add(method);
 136         }
 137
 138         public object this[String key]
 139         {
 140             get { return Dictionary[key]; }
 141             set { Dictionary[key] = value; }
 142         }
 143     }
 144 }