Tools/Castle.DynamicProxy2/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
  16 using Castle.DynamicProxy.Generators;
  17
  18 namespace Castle.DynamicProxy.Serialization
  19 {
  20         using System;
  21         using System.Collections;
  22         using System.Reflection;
  23         using System.Runtime.Serialization;
  24         using Castle.Core.Interceptor;
  25
  26         /// <summary>
  27         /// Handles the deserialization of proxies.
  28         /// See here for more details:
  29         /// http://groups.google.com/group/castle-project-devel/msg/fb5ef9656d050ba5
  30         /// </summary>
  31         [Serializable]
  32         public class ProxyObjectReference : IObjectReference, ISerializable, IDeserializationCallback
  33         {
  34                 private static ModuleScope _scope = new ModuleScope();
  35
  36                 private Type _baseType;
  37                 private Type[] _interfaces;
  38                 private IInterceptor[] _interceptors;
  39                 private ProxySerializer.Indirection _data;
  40                 private object _proxy;
  41
  42                 /// <summary>
  43                 /// Usefull for test cases
  44                 /// </summary>
  45                 public static void ResetScope()
  46                 {
  47                         _scope = new ModuleScope();
  48                 }
  49
  50                 protected ProxyObjectReference(SerializationInfo info, StreamingContext context)
  51                 {
  52                         _interceptors = (IInterceptor[])info.GetValue("__interceptors", typeof (IInterceptor[]));
  53                         _baseType = (Type)info.GetValue("__baseType", typeof(Type));
  54
  55                         String[] _interfaceNames = (String[])info.GetValue("__interfaces", typeof(String[]));
  56
  57                         _interfaces = new Type[_interfaceNames.Length];
  58
  59                         for (int i = 0; i < _interfaceNames.Length; i++)
  60                         {
  61                                 _interfaces[i] = Type.GetType(_interfaceNames[i]);
  62                         }
  63
  64                         _proxy = RecreateProxy(info, context);
  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                         object target = info.GetValue("__target", typeof(object));
  84                         InterfaceGeneratorType generatorType = (InterfaceGeneratorType)info.GetInt32("__interface_generator_type");
  85                         string interfaceName = info.GetString("__theInterface");
  86                         Type theInterface = Type.GetType(interfaceName, true, false);
  87                         InterfaceProxyWithTargetGenerator generator;
  88                         switch (generatorType)
  89                         {
  90                                 case InterfaceGeneratorType.WithTarget:
  91                                         generator = new InterfaceProxyWithTargetGenerator(_scope,theInterface);
  92                                         break;
  93                                 case InterfaceGeneratorType.WithoutTarget:
  94                                         generator = new InterfaceProxyGeneratorWithoutTarget(_scope, theInterface);
  95                                         break;
  96                                 case InterfaceGeneratorType.WithTargetInterface:
  97                                         generator = new InterfaceProxyWithTargetInterfaceGenerator(_scope,      theInterface);
  98                                         break;
  99                                 default:
 100                                         throw new InvalidOperationException(string.Format("Got value {0} for the interface generator type, which is not known for the purpose of serialization.", generatorType));
 101                         }
 102
 103                         Type proxy_type = generator.GenerateCode(target.GetType(), _interfaces , ProxyGenerationOptions.Default);
 104
 105                         proxy = Activator.CreateInstance(proxy_type, new object[] { _interceptors, target });
 106
 107                         return proxy;
 108                 }
 109
 110                 public object RecreateClassProxy(SerializationInfo info, StreamingContext context)
 111                 {
 112                         bool delegateBaseSer = info.GetBoolean("__delegateToBase");
 113
 114                         object proxy = null;
 115
 116                         ClassProxyGenerator cpGen = new ClassProxyGenerator(_scope, _baseType);
 117
 118                         Type proxy_type = cpGen.GenerateCode(_interfaces, ProxyGenerationOptions.Default);
 119
 120
 121                         if (delegateBaseSer)
 122                         {
 123                                 proxy = Activator.CreateInstance(proxy_type, new object[] { info, context });
 124                         }
 125                         else
 126                         {
 127                                 proxy = FormatterServices.GetSafeUninitializedObject(proxy_type);
 128                                 _data = (ProxySerializer.Indirection) info.GetValue("__data", typeof (ProxySerializer.Indirection));
 129
 130                                 SetInterceptor(proxy, proxy_type);
 131                         }
 132
 133                         return proxy;
 134                 }
 135
 136                 private void SetInterceptor (object proxy, Type proxy_type)
 137                 {
 138                         FieldInfo interceptorField = proxy_type.GetField("__interceptors");
 139
 140                         if (interceptorField == null)
 141                         {
 142                                 throw new SerializationException(
 143                                         "The SerializationInfo specifies an invalid proxy type, which has no __interceptors field.");
 144                         }
 145
 146                         interceptorField.SetValue (proxy, _interceptors);
 147                 }
 148
 149                 protected void InvokeCallback(object target)
 150                 {
 151                         if (target is IDeserializationCallback)
 152                         {
 153                                 (target as IDeserializationCallback).OnDeserialization(this);
 154                         }
 155                 }
 156
 157                 public object GetRealObject(StreamingContext context)
 158                 {
 159                         return _proxy;
 160                 }
 161
 162                 public void GetObjectData(SerializationInfo info, StreamingContext context)
 163                 {
 164                         // There is no need to implement this method as
 165                         // this class would never be serialized.
 166                 }
 167
 168     // Class proxies must be populated in this method, since only at this point all members held by _data.IndirectedObject
 169     // have been fixed up.
 170                 public void OnDeserialization (object sender)
 171                 {
 172                         if (_data != null)
 173                         {
 174                                 object[] objectData = (object[]) _data.IndirectedObject;
 175
 176                                 MemberInfo[] members = FormatterServices.GetSerializableMembers (_baseType);
 177                                 FormatterServices.PopulateObjectMembers (_proxy, members, objectData);
 178                                 _data = null;
 179       }
 180       InvokeCallback (_proxy);
 181     }
 182         }
 183 }