Tools/DynamicProxy/Castle.DynamicProxy/Serialization/ProxyObjectReference.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.Serialization
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Reflection;
  20         using System.Runtime.Serialization;
  21
  22         using Castle.DynamicProxy.Builder.CodeGenerators;
  23
  24         /// <summary>
  25         /// Handles the deserialization of proxies.
  26         /// </summary>
  27         [Serializable]
  28         public class ProxyObjectReference : IObjectReference, ISerializable
  29         {
  30                 private static ModuleScope _scope = new ModuleScope();
  31
  32                 private Type _baseType;
  33                 private Type[] _interfaces;
  34                 private IInterceptor _interceptor;
  35                 private object[] _mixins;
  36                 private object[] _data;
  37                 private object _proxy;
  38
  39                 /// <summary>
  40                 /// Usefull for test cases
  41                 /// </summary>
  42                 public static void ResetScope()
  43                 {
  44                         _scope = new ModuleScope();
  45                 }
  46
  47                 protected ProxyObjectReference(SerializationInfo info, StreamingContext context)
  48                 {
  49                         _interceptor = (IInterceptor) info.GetValue("__interceptor", typeof(IInterceptor) );
  50                         _baseType = (Type) info.GetValue("__baseType", typeof(Type) );
  51                         _mixins = (object[]) info.GetValue("__mixins", typeof(object[]) );
  52
  53                         String[] _interfaceNames = (String[]) info.GetValue("__interfaces", typeof(String[]) );
  54
  55                         _interfaces = new Type[_interfaceNames.Length];
  56
  57                         for (int i = 0; i < _interfaceNames.Length; i++)
  58                         {
  59                                 _interfaces[i] = Type.GetType(_interfaceNames[i]);
  60                         }
  61
  62                         _proxy = RecreateProxy(info, context);
  63
  64                         InvokeCallback(_proxy);
  65                 }
  66
  67                 protected virtual object RecreateProxy(SerializationInfo info, StreamingContext context)
  68                 {
  69                         if (_baseType == typeof(object))
  70                         {
  71                                 return RecreateInterfaceProxy(info, context);
  72                         }
  73                         else
  74                         {
  75                                 return RecreateClassProxy(info, context);
  76                         }
  77                 }
  78
  79                 public object RecreateInterfaceProxy(SerializationInfo info, StreamingContext context)
  80                 {
  81                         object proxy = null;
  82
  83                         GeneratorContext genContext = new GeneratorContext();
  84
  85                         foreach(object mixin in _mixins)
  86                         {
  87                                 genContext.AddMixinInstance(mixin);
  88                         }
  89
  90                         InterfaceProxyGenerator gen = new InterfaceProxyGenerator( _scope, genContext );
  91
  92                         object target = info.GetValue("__target", typeof(object));
  93
  94                         if (_mixins.Length == 0)
  95                         {
  96                                 Type proxy_type = gen.GenerateCode( _interfaces, target.GetType());
  97
  98                                 proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor, target } );
  99                         }
 100                         else
 101                         {
 102                                 Type proxy_type = gen.GenerateCode( _interfaces, target.GetType() );
 103
 104                                 proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor, target, genContext.MixinsAsArray() } );
 105                         }
 106
 107                         return proxy;
 108                 }
 109
 110                 public object RecreateClassProxy(SerializationInfo info, StreamingContext context)
 111                 {
 112                         bool delegateBaseSer = info.GetBoolean("__delegateToBase");
 113
 114                         if (!delegateBaseSer)
 115                         {
 116                                 _data = (object[]) info.GetValue("__data", typeof(object[]) );
 117                         }
 118
 119                         object proxy = null;
 120
 121                         GeneratorContext genContext = new GeneratorContext();
 122
 123                         if (_mixins.Length != 0)
 124                         {
 125                                 foreach(object mixin in _mixins)
 126                                 {
 127                                         genContext.AddMixinInstance(mixin);
 128                                 }
 129                         }
 130
 131                         ClassProxyGenerator cpGen = new ClassProxyGenerator( _scope, genContext );
 132
 133                         Type proxy_type;
 134
 135                         if (_mixins.Length == 0)
 136                         {
 137                                 proxy_type = cpGen.GenerateCode( _baseType, _interfaces );
 138                         }
 139                         else
 140                         {
 141                                 proxy_type = cpGen.GenerateCustomCode( _baseType, _interfaces );
 142                         }
 143
 144                         if (delegateBaseSer)
 145                         {
 146                                 proxy = Activator.CreateInstance( proxy_type, new object[] { info, context } );
 147                         }
 148                         else
 149                         {
 150                                 if (_mixins.Length == 0)
 151                                 {
 152                                         proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor } );
 153                                 }
 154                                 else
 155                                 {
 156                                         ArrayList args = new ArrayList();
 157                                         args.Add(_interceptor);
 158                                         args.Add(genContext.MixinsAsArray());
 159
 160                                         proxy = Activator.CreateInstance( proxy_type, args.ToArray() );
 161                                 }
 162
 163                                 MemberInfo[] members = FormatterServices.GetSerializableMembers( _baseType );
 164                                 FormatterServices.PopulateObjectMembers(proxy, members, _data);
 165                         }
 166
 167                         return proxy;
 168                 }
 169
 170                 protected void InvokeCallback(object target)
 171                 {
 172                         if (target is IDeserializationCallback)
 173                         {
 174                                 (target as IDeserializationCallback).OnDeserialization(this);
 175                         }
 176                 }
 177
 178                 public object GetRealObject(StreamingContext context)
 179                 {
 180                         return _proxy;
 181                 }
 182
 183                 public void GetObjectData(SerializationInfo info, StreamingContext context)
 184                 {
 185                         // There is no need to implement this method as
 186                         // this class would never be serialized.
 187                 }
 188         }
 189 }