?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
DYNPROXY-58 - Inherited interfaces - FIXED.
[castle.git] / Tools / Castle.DynamicProxy2 / Castle.DynamicProxy / Generators / InterfaceProxyWithTargetGenerator.cs
blob9829e01969279c2757067217aa7ed55486991d1d
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 using System;
16 using System.Collections;
17 using System.Collections.Generic;
18 using System.Reflection;
19 using System.Runtime.Serialization;
20 using System.Threading;
21 using System.Xml.Serialization;
22 using Castle.Core.Interceptor;
23 using Castle.DynamicProxy.Generators.Emitters;
24 using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
25 using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
26
27 namespace Castle.DynamicProxy.Generators
28 {
29 #if DOTNET2
30 using System.Collections.Generic;
31 #endif
32
33
34 /// <summary>
35 ///
36 /// </summary>
37 [CLSCompliant(false)]
38 public class InterfaceProxyWithTargetGenerator : BaseProxyGenerator
39 {
40 private FieldReference targetField;
41 protected Hashtable method2Invocation = new Hashtable();
42 protected Hashtable method2methodOnTarget = new Hashtable();
43
44 public InterfaceProxyWithTargetGenerator(ModuleScope scope, Type theInterface)
45 : base(scope, theInterface)
46 {
47 CheckNotGenericTypeDefinition(theInterface, "theInterface");
48 }
49
50 public Type GenerateCode(Type proxyTargetType, Type[] interfaces, ProxyGenerationOptions options)
51 {
52 CheckNotGenericTypeDefinition(proxyTargetType, "proxyTargetType");
53 CheckNotGenericTypeDefinitions(interfaces, "interfaces");
54 Type generatedType;
55
56 ReaderWriterLock rwlock = Scope.RWLock;
57
58 rwlock.AcquireReaderLock(-1);
59
60 CacheKey cacheKey = new CacheKey(targetType, interfaces, options);
61
62 Type cacheType = GetFromCache(cacheKey);
63
64 if (cacheType != null)
65 {
66 rwlock.ReleaseReaderLock();
67
68 return cacheType;
69 }
70
71 rwlock.UpgradeToWriterLock(-1);
72
73 try
74 {
75 cacheType = GetFromCache(cacheKey);
76
77 if (cacheType != null)
78 {
79 return cacheType;
80 }
81
82 generationHook = options.Hook;
83
84 String newName = targetType.Name + "Proxy" + Guid.NewGuid().ToString("N");
85
86 // Add Interfaces that the proxy implements
87
88 ArrayList interfaceList = new ArrayList();
89
90 interfaceList.Add(targetType);
91
92 if (interfaces != null)
93 {
94 interfaceList.AddRange(interfaces);
95 }
96 if (!interfaceList.Contains(typeof (ISerializable)))
97 interfaceList.Add(typeof (ISerializable));
98
99 AddMixinInterfaces(options, interfaceList);
100 AddDefaultInterfaces(interfaceList);
101
102 Type baseType = options.BaseTypeForInterfaceProxy;
103
104 ClassEmitter emitter = BuildClassEmitter(newName, baseType, interfaceList);
105 emitter.DefineCustomAttribute(new XmlIncludeAttribute(targetType));
106 emitter.DefineCustomAttribute(new SerializableAttribute());
107
108 // Custom attributes
109 ReplicateNonInheritableAttributes(targetType, emitter);
110
111 // Fields generations
112
113 FieldReference interceptorsField = emitter.CreateField("__interceptors", typeof (IInterceptor[]));
114 targetField = emitter.CreateField("__target", proxyTargetType);
115
116 emitter.DefineCustomAttributeFor(interceptorsField, new XmlIgnoreAttribute());
117 emitter.DefineCustomAttributeFor(targetField, new XmlIgnoreAttribute());
118
119 // Implement builtin Interfaces
120
121 ImplementProxyTargetAccessor(targetType, emitter, interceptorsField);
122
123 // Collect methods
124
125 PropertyToGenerate[] propsToGenerate;
126 EventToGenerate[] eventsToGenerate;
127 MethodInfo[] methods = CollectMethodsAndProperties(emitter, targetType, out propsToGenerate, out eventsToGenerate);
128
129 if (interfaces != null && interfaces.Length != 0)
130 {
131 ArrayList tmpInterfaces = new ArrayList(interfaces);
132
133 foreach (Type inter in interfaces)
134 {
135 if (inter.IsAssignableFrom(proxyTargetType))
136 {
137 PropertyToGenerate[] tempPropsToGenerate;
138 EventToGenerate[] tempEventToGenerates;
139 MethodInfo[] methodsTemp = CollectMethodsAndProperties(emitter, inter, out tempPropsToGenerate, out tempEventToGenerates);
140
141 PropertyToGenerate[] newPropsToGenerate = new PropertyToGenerate[tempPropsToGenerate.Length + propsToGenerate.Length];
142 MethodInfo[] newMethods = new MethodInfo[methodsTemp.Length + methods.Length];
143 EventToGenerate[] newEvents = new EventToGenerate[eventsToGenerate.Length + tempEventToGenerates.Length];
144
145 Array.Copy(methods, newMethods, methods.Length);
146 Array.Copy(methodsTemp, 0, newMethods, methods.Length, methodsTemp.Length);
147
148 Array.Copy(propsToGenerate, newPropsToGenerate, propsToGenerate.Length);
149 Array.Copy(tempPropsToGenerate, 0, newPropsToGenerate, propsToGenerate.Length, tempPropsToGenerate.Length);
150
151 Array.Copy(eventsToGenerate, newEvents, eventsToGenerate.Length);
152 Array.Copy(tempEventToGenerates, 0, newEvents, eventsToGenerate.Length, tempEventToGenerates.Length);
153
154 methods = newMethods;
155 propsToGenerate = newPropsToGenerate;
156 eventsToGenerate = newEvents;
157
158 tmpInterfaces.Remove(inter);
159 }
160 }
161
162 interfaces = (Type[]) tmpInterfaces.ToArray(typeof (Type));
163 }
164
165 methods = RegisterMixinMethodsAndProperties(emitter, options, methods, ref propsToGenerate, ref eventsToGenerate);
166
167 options.Hook.MethodsInspected();
168
169 // Constructor
170
171 ConstructorEmitter typeInitializer = GenerateStaticConstructor(emitter);
172
173 // InterfaceProxyGeneratorWithTargetInterface gets duplicate method exceptions from BaseProxyGenerator with this... -jlewalle
174 if (!proxyTargetType.IsInterface)
175 {
176 CacheMethodTokens(emitter,
177 proxyTargetType.GetMethods(BindingFlags.Public | BindingFlags.Instance),
178 typeInitializer);
179 }
180
181 CreateInitializeCacheMethodBody(proxyTargetType, methods, emitter, typeInitializer);
182 FieldReference[] mixinFields = AddMixinFields(options, emitter);
183 List<FieldReference> fields = new List<FieldReference>(mixinFields);
184 fields.Add(interceptorsField);
185 fields.Add(targetField);
186 GenerateConstructors(emitter, baseType, fields.ToArray());
187 // GenerateParameterlessConstructor(emitter, interceptorsField, baseType);
188
189 // Implement interfaces
190
191 if (interfaces != null && interfaces.Length != 0)
192 {
193 foreach (Type inter in interfaces)
194 {
195 ImplementBlankInterface(targetType, inter, emitter, interceptorsField, typeInitializer);
196 }
197 }
198
199 // Create invocation types
200
201 foreach (MethodInfo method in methods)
202 {
203 CreateInvocationForMethod(emitter, method, proxyTargetType);
204 }
205
206 // Create methods overrides
207
208 Dictionary<MethodInfo, MethodEmitter> method2Emitter = new Dictionary<MethodInfo, MethodEmitter>();
209
210 foreach (MethodInfo method in methods)
211 {
212 if (method.IsSpecialName &&
213 (method.Name.StartsWith("get_") || method.Name.StartsWith("set_") ||
214 method.Name.StartsWith("add_") || method.Name.StartsWith("remove_")) ||
215 methodsToSkip.Contains(method))
216 {
217 continue;
218 }
219
220 NestedClassEmitter nestedClass = (NestedClassEmitter) method2Invocation[method];
221
222 // TODO: Should the targetType be a generic definition or instantiation
223
224 MethodEmitter newProxiedMethod = CreateProxiedMethod(
225 targetType, method, emitter, nestedClass, interceptorsField, GetTargetRef(method, mixinFields, targetField),
226 ConstructorVersion.WithTargetMethod, (MethodInfo) method2methodOnTarget[method]);
227
228 ReplicateNonInheritableAttributes(method, newProxiedMethod);
229
230 method2Emitter[method] = newProxiedMethod;
231
232 ParameterInfo[] parameters = method.GetParameters();
233 // ParameterInfo[] parametersProxy = newProxiedMethod.MethodBuilder.GetParameters();
234
235 // bool useDefineOverride = true;
236 /*
237 for (int i = 0; i < parameters.Length; i++)
238 {
239 // ParameterInfo paramInfo = parameters[i];
240 // ParameterInfo paramInfo2 = parametersProxy[i];
241
242 // Console.WriteLine("{0} {1} {2} {3}", paramInfo.Name, paramInfo.ParameterType, paramInfo.Attributes, paramInfo.Position);
243 // Console.WriteLine("{0} {1} {2} {3}", paramInfo2.Name, paramInfo2.ParameterType, paramInfo2.Attributes, paramInfo2.Position);
244 }
245
246 // if (useDefineOverride)
247 // {
248 // emitter.TypeBuilder.DefineMethodOverride(newProxiedMethod.MethodBuilder, method);
249 // }*/
250 }
251
252 foreach (PropertyToGenerate propToGen in propsToGenerate)
253 {
254 if (propToGen.CanRead)
255 {
256 NestedClassEmitter nestedClass = (NestedClassEmitter) method2Invocation[propToGen.GetMethod];
257
258 MethodAttributes atts = ObtainMethodAttributes(propToGen.GetMethod);
259
260 MethodEmitter getEmitter = propToGen.Emitter.CreateGetMethod(atts);
261
262 ImplementProxiedMethod(targetType, getEmitter,
263 propToGen.GetMethod, emitter,
264 nestedClass, interceptorsField, targetField,
265 ConstructorVersion.WithTargetMethod, (MethodInfo) method2methodOnTarget[propToGen.GetMethod]);
266
267 ReplicateNonInheritableAttributes(propToGen.GetMethod, getEmitter);
268
269 // emitter.TypeBuilder.DefineMethodOverride(getEmitter.MethodBuilder, propToGen.GetMethod);
270 }
271
272 if (propToGen.CanWrite)
273 {
274 NestedClassEmitter nestedClass = (NestedClassEmitter) method2Invocation[propToGen.SetMethod];
275
276 MethodAttributes atts = ObtainMethodAttributes(propToGen.SetMethod);
277
278 MethodEmitter setEmitter = propToGen.Emitter.CreateSetMethod(atts);
279
280 ImplementProxiedMethod(targetType, setEmitter,
281 propToGen.SetMethod, emitter,
282 nestedClass, interceptorsField, targetField,
283 ConstructorVersion.WithTargetMethod, (MethodInfo) method2methodOnTarget[propToGen.SetMethod]);
284
285 ReplicateNonInheritableAttributes(propToGen.SetMethod, setEmitter);
286
287 // emitter.TypeBuilder.DefineMethodOverride(setEmitter.MethodBuilder, propToGen.SetMethod);
288 }
289 }
290
291
292 foreach (EventToGenerate eventToGenerate in eventsToGenerate)
293 {
294 NestedClassEmitter add_nestedClass = (NestedClassEmitter) method2Invocation[eventToGenerate.AddMethod];
295
296 MethodAttributes add_atts = ObtainMethodAttributes(eventToGenerate.AddMethod);
297
298 MethodEmitter addEmitter = eventToGenerate.Emitter.CreateAddMethod(add_atts);
299
300 ImplementProxiedMethod(targetType, addEmitter,
301 eventToGenerate.AddMethod, emitter,
302 add_nestedClass, interceptorsField, targetField,
303 ConstructorVersion.WithTargetMethod, (MethodInfo) method2methodOnTarget[eventToGenerate.AddMethod]);
304
305 ReplicateNonInheritableAttributes(eventToGenerate.AddMethod, addEmitter);
306
307
308 NestedClassEmitter remove_nestedClass = (NestedClassEmitter) method2Invocation[eventToGenerate.RemoveMethod];
309
310 MethodAttributes remove_atts = ObtainMethodAttributes(eventToGenerate.RemoveMethod);
311
312 MethodEmitter removeEmitter = eventToGenerate.Emitter.CreateRemoveMethod(remove_atts);
313
314 ImplementProxiedMethod(targetType, removeEmitter,
315 eventToGenerate.RemoveMethod, emitter,
316 remove_nestedClass, interceptorsField, targetField,
317 ConstructorVersion.WithTargetMethod, (MethodInfo) method2methodOnTarget[eventToGenerate.RemoveMethod]);
318
319 ReplicateNonInheritableAttributes(eventToGenerate.RemoveMethod, removeEmitter);
320 }
321
322 ImplementGetObjectData(emitter, interceptorsField, interfaces);
323
324 // Complete Initialize
325
326 CompleteInitCacheMethod(typeInitializer.CodeBuilder);
327
328 // Crosses fingers and build type
329
330 generatedType = emitter.BuildType();
331
332 /*foreach (MethodInfo m in generatedType.GetMethods())
333 {
334 ParameterInfo[] parameters = m.GetParameters();
335
336 // Console.WriteLine(m.Name);
337
338 for (int i = 0; i < parameters.Length; i++)
339 {
340 ParameterInfo paramInfo = parameters[i];
341
342 // Console.WriteLine("{0} {1} {2} {3}", paramInfo.Name, paramInfo.ParameterType, paramInfo.Attributes, paramInfo.Position);
343 // Console.WriteLine("{0} {1} {2} {3}", paramInfo2.Name, paramInfo2.ParameterType, paramInfo2.Attributes, paramInfo2.Position);
344 }
345 }
346 */
347
348 AddToCache(cacheKey, generatedType);
349 }
350 finally
351 {
352 rwlock.ReleaseWriterLock();
353 }
354
355 Scope.SaveAssembly();
356
357 return generatedType;
358 }
359
360 protected virtual void CreateInvocationForMethod(ClassEmitter emitter, MethodInfo method, Type proxyTargetType)
361 {
362 MethodInfo methodOnTarget = FindMethodOnTargetType(method, proxyTargetType, true);
363
364 method2methodOnTarget[method] = methodOnTarget;
365
366 method2Invocation[method] = BuildInvocationNestedType(emitter, proxyTargetType,
367 GetMethodTargetType(methodOnTarget),
368 method, methodOnTarget,
369 ConstructorVersion.WithTargetMethod);
370 }
371
372 /// <summary>
373 /// Finds the type of the method on target.
374 /// </summary>
375 /// <param name="methodOnInterface">The method on interface.</param>
376 /// <param name="proxyTargetType">Type of the proxy target.</param>
377 /// <param name="checkMixins">if set to <c>true</c> will check implementation on mixins.</param>
378 /// <returns></returns>
379 protected MethodInfo FindMethodOnTargetType(MethodInfo methodOnInterface, Type proxyTargetType, bool checkMixins)
380 {
381 #if DOTNET2
382 // The code below assumes that the target
383 // class uses the same generic arguments
384 // as the interface generic arguments
385 List<MethodInfo> members = GetMembers(methodOnInterface, proxyTargetType);
386
387 if (members.Count == 0)
388 {
389 // Before throwing an exception, we look for an explicit
390 // interface method implementation
391
392 MethodInfo[] privateMethods = proxyTargetType.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance);
393
394 foreach (MethodInfo methodInfo in privateMethods)
395 {
396 // We make sure it is a method used for explicit implementation
397
398 if (!methodInfo.IsFinal || !methodInfo.IsVirtual || !methodInfo.IsHideBySig)
399 {
400 continue;
401 }
402
403 if (IsEquivalentMethod(methodInfo, methodOnInterface))
404 {
405 throw new GeneratorException(String.Format("DynamicProxy cannot create an interface (with target) " +
406 "proxy for '{0}' as the target '{1}' has an explicit implementation of one of the methods exposed by the interface. " +
407 "The runtime prevents use from invoking the private method on the target. Method {2}",
408 methodOnInterface.DeclaringType.Name, methodInfo.DeclaringType.Name, methodInfo.Name));
409 }
410 }
411 }
412
413 if (members.Count > 1)
414 {
415 throw new GeneratorException("Found more than one method on target " + proxyTargetType.FullName + " matching " + methodOnInterface.Name);
416 }
417 else if (members.Count == 0)
418 {
419 if (checkMixins && IsMixinMethod(methodOnInterface))
420 {
421 return FindMethodOnTargetType(methodOnInterface, method2MixinType[methodOnInterface], false);
422 }
423 throw new GeneratorException("Could not find a matching method on " + proxyTargetType.FullName + ". Method " + methodOnInterface.Name);
424 }
425
426 return (MethodInfo) members[0];
427
428 #else
429 ParameterInfo[] parameters = methodOnInterface.GetParameters();
430 Type[] argTypes = new Type[parameters.Length];
431
432 for(int i=0; i < parameters.Length; i++)
433 {
434 argTypes[i] = parameters[i].ParameterType;
435 }
436
437 return proxyTargetType.GetMethod(methodOnInterface.Name, argTypes);
438 #endif
439 }
440
441 private static List<MethodInfo> GetMembers(MethodInfo methodOnInterface, Type proxyTargetType)
442 {
443
444 List<MethodInfo> members = new List<MethodInfo>();
445 foreach (MethodInfo method in proxyTargetType.GetMethods(BindingFlags.Public | BindingFlags.Instance))
446 {
447 if (method.Name != methodOnInterface.Name) continue;
448
449 if (IsEquivalentMethod(method, methodOnInterface))
450 members.Add(method);
451 }
452 if (members.Count > 0 || proxyTargetType.IsClass)
453 return members;
454 //didn't find it here, and we are looking at an interface, so we want to try the
455 // base interfaces as well
456 foreach (Type type in proxyTargetType.GetInterfaces())
457 {
458 members.AddRange(GetMembers(methodOnInterface, type));
459 if (members.Count > 0)
460 return members;
461 }
462 return members;
463 }
464
465 /// <summary>
466 /// Checks whether the given types are the same. This is
467 /// more complicated than it looks.
468 /// </summary>
469 /// <param name="sourceType"></param>
470 /// <param name="targetType"></param>
471 /// <returns></returns>
472 public static bool IsTypeEquivalent(Type sourceType, Type targetType)
473 {
474 if (sourceType.IsGenericParameter)
475 {
476 if (sourceType.Name != targetType.Name)
477 {
478 return false;
479 }
480 }
481 else
482 {
483 if (sourceType.IsGenericType != targetType.IsGenericType)
484 {
485 return false;
486 }
487 else if (sourceType.IsArray != targetType.IsArray)
488 {
489 return false;
490 }
491
492 if (sourceType.IsGenericType)
493 {
494 if (sourceType.GetGenericTypeDefinition() != targetType.GetGenericTypeDefinition())
495 {
496 return false;
497 }
498
499 // Compare generic arguments
500
501 Type[] sourceGenArgs = sourceType.GetGenericArguments();
502 Type[] targetGenArgs = targetType.GetGenericArguments();
503
504 for (int i = 0; i < sourceGenArgs.Length; i++)
505 {
506 if (!IsTypeEquivalent(sourceGenArgs[i], targetGenArgs[i]))
507 {
508 return false;
509 }
510 }
511 }
512 else if (sourceType.IsArray)
513 {
514 Type sourceArrayType = sourceType.GetElementType();
515 Type targetArrayType = targetType.GetElementType();
516
517 if (!IsTypeEquivalent(sourceArrayType, targetArrayType))
518 {
519 return false;
520 }
521
522 int sourceRank = sourceType.GetArrayRank();
523 int targetRank = targetType.GetArrayRank();
524
525 if (sourceRank != targetRank)
526 {
527 return false;
528 }
529 }
530 else if (sourceType != targetType)
531 {
532 return false;
533 }
534 }
535
536 return true;
537 }
538
539 protected override Reference GetProxyTargetReference()
540 {
541 return targetField;
542 }
543
544 protected override bool CanOnlyProxyVirtual()
545 {
546 return false;
547 }
548
549 private static bool IsEquivalentMethod(MethodInfo methodInfo, MethodInfo methodOnInterface)
550 {
551 // Check return type equivalence
552
553 if (!IsTypeEquivalent(methodInfo.ReturnType, methodOnInterface.ReturnType))
554 {
555 return false;
556 }
557
558 // Check parameters equivalence
559
560 ParameterInfo[] sourceParams = methodOnInterface.GetParameters();
561 ParameterInfo[] targetParams = methodInfo.GetParameters();
562
563 if (sourceParams.Length != targetParams.Length)
564 {
565 return false;
566 }
567
568 for (int i = 0; i < sourceParams.Length; i++)
569 {
570 Type sourceParamType = sourceParams[i].ParameterType;
571 Type targetParamType = targetParams[i].ParameterType;
572
573 if (!IsTypeEquivalent(sourceParamType, targetParamType))
574 {
575 return false;
576 }
577 }
578
579 return true;
580 }
581
582 protected override void CustomizeGetObjectData(
583 AbstractCodeBuilder codebuilder, ArgumentReference arg1,
584 ArgumentReference arg2)
585 {
586 Type[] key_and_object = new Type[] {typeof (String), typeof (Object)};
587 Type[] key_and_int = new Type[] {typeof (String), typeof (int)};
588 Type[] key_and_string = new Type[] {typeof (String), typeof (string)};
589 MethodInfo addValueMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_object);
590 MethodInfo addIntMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_int);
591 MethodInfo addStringMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_string);
592
593 codebuilder.AddStatement(new ExpressionStatement(
594 new MethodInvocationExpression(arg1, addValueMethod,
595 new ConstReference("__target").ToExpression(),
596 targetField.ToExpression())));
597
598 codebuilder.AddStatement(new ExpressionStatement(
599 new MethodInvocationExpression(arg1, addIntMethod,
600 new ConstReference("__interface_generator_type").ToExpression(),
601 new ConstReference((int) GeneratorType).ToExpression())));
602
603 codebuilder.AddStatement(new ExpressionStatement(
604 new MethodInvocationExpression(arg1, addStringMethod,
605 new ConstReference("__theInterface").ToExpression(),
606 new ConstReference(targetType.AssemblyQualifiedName).ToExpression())));
607 }
608
609 protected virtual InterfaceGeneratorType GeneratorType
610 {
611 get { return InterfaceGeneratorType.WithTarget; }
612 }
613 }
614
615 /// <summary>
616 /// This is used by the ProxyObjectReference class durin de-serialiation, to know
617 /// which generator it should use
618 /// </summary>
619 public enum InterfaceGeneratorType
620 {
621 WithTarget = 1,
622 WithoutTarget = 2,
623 WithTargetInterface = 3
624 }
625 }
Git import of castle svn