?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added container accessor to Castle.Core
[castle.git] / Tools / Castle.DynamicProxy2 / Castle.DynamicProxy / Generators / BaseProxyGenerator.cs
blob6240e74f09881b6f33b16f80e5a8e3d7578eb650
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.Generators
16 {
17 using System;
18 using System.Collections;
19 using System.Collections.Generic;
20 using System.Diagnostics;
21 using System.Reflection;
22 using System.Reflection.Emit;
23 using System.Runtime.InteropServices;
24 using System.Runtime.Serialization;
25 using Castle.Core.Interceptor;
26 using Castle.DynamicProxy.Generators.Emitters;
27 using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
28 using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
29 using Castle.DynamicProxy.Serialization;
30
31 public enum ConstructorVersion
32 {
33 WithTargetMethod,
34 WithoutTargetMethod
35 }
36
37 /// <summary>
38 /// Base class that exposes the common functionalities
39 /// to proxy generation.
40 /// </summary>
41 /// <remarks>
42 /// TODO:
43 /// - Use the interceptor selector if provided
44 /// - Add tests and fixes for 'leaking this' problem
45 /// - Mixin support
46 /// </remarks>
47 public abstract class BaseProxyGenerator
48 {
49 private static MethodInfo invocation_getArgumentsMethod = typeof(AbstractInvocation).GetMethod("get_Arguments");
50
51 private readonly ModuleScope scope;
52 private int nestedCounter, callbackCounter;
53 private int fieldCount = 1;
54 private FieldReference typeTokenField;
55 private Hashtable method2TokenField = new Hashtable();
56 private IList generateNewSlot = new ArrayList();
57 protected IList methodsToSkip = new ArrayList();
58 private ProxyGenerationOptions proxyGenerationOptions;
59 private FieldReference proxyGenerationOptionsField;
60
61 protected readonly Type targetType;
62 protected ConstructorInfo serializationConstructor;
63
64 protected BaseProxyGenerator(ModuleScope scope, Type targetType)
65 {
66 this.scope = scope;
67 this.targetType = targetType;
68 }
69
70 public ProxyGenerationOptions ProxyGenerationOptions
71 {
72 get {
73 if (proxyGenerationOptions == null)
74 {
75 throw new InvalidOperationException ("ProxyGenerationOptions must be set before being retrieved.");
76 }
77 return proxyGenerationOptions;
78 }
79 }
80
81 protected void SetGenerationOptions (ProxyGenerationOptions options, ClassEmitter emitter)
82 {
83 if (proxyGenerationOptions != null)
84 {
85 throw new InvalidOperationException ("ProxyGenerationOptions can only be set once.");
86 }
87 proxyGenerationOptions = options;
88 proxyGenerationOptionsField = emitter.CreateStaticField ("proxyGenerationOptions", typeof (ProxyGenerationOptions));
89 }
90
91 protected void InitializeStaticFields (Type builtType)
92 {
93 builtType.GetField (proxyGenerationOptionsField.Reference.Name).SetValue (null, ProxyGenerationOptions);
94 }
95
96 protected void CheckNotGenericTypeDefinition(Type type, string argumentName)
97 {
98 if (type != null && type.IsGenericTypeDefinition)
99 {
100 throw new ArgumentException("Type cannot be a generic type definition. Type: " + type.FullName, argumentName);
101 }
102 }
103
104 protected void CheckNotGenericTypeDefinitions(IEnumerable types, string argumentName)
105 {
106 if (types != null)
107 {
108 foreach(Type t in types)
109 {
110 CheckNotGenericTypeDefinition(t, argumentName);
111 }
112 }
113 }
114
115 protected ModuleScope Scope
116 {
117 get { return scope; }
118 }
119
120 protected virtual ClassEmitter BuildClassEmitter(String typeName, Type parentType, IList interfaceList)
121 {
122 CheckNotGenericTypeDefinition(parentType, "parentType");
123 CheckNotGenericTypeDefinitions(interfaceList, "interfaceList");
124
125 Type[] interfaces = new Type[interfaceList.Count];
126
127 interfaceList.CopyTo(interfaces, 0);
128
129 return BuildClassEmitter(typeName, parentType, interfaces);
130 }
131
132 protected virtual ClassEmitter BuildClassEmitter(String typeName, Type parentType, Type[] interfaces)
133 {
134 CheckNotGenericTypeDefinition(parentType, "parentType");
135 CheckNotGenericTypeDefinitions(interfaces, "interfaceList");
136
137 if (interfaces == null)
138 {
139 interfaces = new Type[0];
140 }
141
142 return new ClassEmitter(Scope, typeName, parentType, interfaces);
143 }
144
145 /// <summary>
146 /// Used by dinamically implement <see cref="Core.Interceptor.IProxyTargetAccessor"/>
147 /// </summary>
148 /// <returns></returns>
149 protected abstract Reference GetProxyTargetReference();
150
151 protected abstract bool CanOnlyProxyVirtual();
152
153 #region Cache related
154
155 protected Type GetFromCache(CacheKey key)
156 {
157 return scope.GetFromCache(key);
158 }
159
160 protected void AddToCache(CacheKey key, Type type)
161 {
162 scope.RegisterInCache(key, type);
163 }
164
165 #endregion
166
167 protected MethodEmitter CreateProxiedMethod(
168 Type targetType,
169 MethodInfo method,
170 ClassEmitter emitter,
171 NestedClassEmitter invocationImpl,
172 FieldReference interceptorsField,
173 Reference targetRef,
174 ConstructorVersion version,
175 MethodInfo methodOnTarget)
176 {
177 CheckNotGenericTypeDefinition(targetType, "targetType");
178
179 MethodAttributes atts = ObtainMethodAttributes(method);
180 MethodEmitter methodEmitter = emitter.CreateMethod(method.Name, atts);
181
182 return
183 ImplementProxiedMethod(targetType,
184 methodEmitter,
185 method,
186 emitter,
187 invocationImpl,
188 interceptorsField,
189 targetRef,
190 version,
191 methodOnTarget);
192 }
193
194 protected void ImplementBlankInterface(
195 Type targetType,
196 Type _interface,
197 ClassEmitter emitter,
198 FieldReference interceptorsField,
199 ConstructorEmitter typeInitializerConstructor)
200 {
201 CheckNotGenericTypeDefinition(targetType, "targetType");
202 CheckNotGenericTypeDefinition(_interface, "_interface");
203
204 PropertyToGenerate[] propsToGenerate;
205 EventToGenerate[] eventsToGenerate;
206 MethodInfo[] methods =
207 CollectMethodsAndProperties(emitter, _interface, false, out propsToGenerate, out eventsToGenerate);
208
209 Dictionary<MethodInfo, NestedClassEmitter> method2Invocation = new Dictionary<MethodInfo, NestedClassEmitter>();
210
211 foreach(MethodInfo method in methods)
212 {
213 AddFieldToCacheMethodTokenAndStatementsToInitialize(method, typeInitializerConstructor, emitter);
214
215 method2Invocation[method] =
216 BuildInvocationNestedType(emitter,
217 targetType,
218 emitter.TypeBuilder,
219 method,
220 null,
221 ConstructorVersion.WithoutTargetMethod);
222 }
223
224 foreach(MethodInfo method in methods)
225 {
226 if (method.IsSpecialName && (method.Name.StartsWith("get_") || method.Name.StartsWith("set_")))
227 {
228 continue;
229 }
230
231 NestedClassEmitter nestedClass = method2Invocation[method];
232
233 MethodEmitter newProxiedMethod =
234 CreateProxiedMethod(targetType,
235 method,
236 emitter,
237 nestedClass,
238 interceptorsField,
239 SelfReference.Self,
240 ConstructorVersion.WithoutTargetMethod,
241 null);
242
243 ReplicateNonInheritableAttributes(method, newProxiedMethod);
244 }
245
246 foreach(PropertyToGenerate propToGen in propsToGenerate)
247 {
248 if (propToGen.CanRead)
249 {
250 NestedClassEmitter nestedClass = method2Invocation[propToGen.GetMethod];
251
252 MethodAttributes atts = ObtainMethodAttributes(propToGen.GetMethod);
253
254 MethodEmitter getEmitter = propToGen.Emitter.CreateGetMethod(atts);
255
256 ImplementProxiedMethod(targetType,
257 getEmitter,
258 propToGen.GetMethod,
259 emitter,
260 nestedClass,
261 interceptorsField,
262 SelfReference.Self,
263 ConstructorVersion.WithoutTargetMethod,
264 null);
265
266 ReplicateNonInheritableAttributes(propToGen.GetMethod, getEmitter);
267 }
268
269 if (propToGen.CanWrite)
270 {
271 NestedClassEmitter nestedClass = method2Invocation[propToGen.SetMethod];
272
273 MethodAttributes atts = ObtainMethodAttributes(propToGen.SetMethod);
274
275 MethodEmitter setEmitter = propToGen.Emitter.CreateSetMethod(atts);
276
277 ImplementProxiedMethod(targetType,
278 setEmitter,
279 propToGen.SetMethod,
280 emitter,
281 nestedClass,
282 interceptorsField,
283 SelfReference.Self,
284 ConstructorVersion.WithoutTargetMethod,
285 null);
286
287 ReplicateNonInheritableAttributes(propToGen.SetMethod, setEmitter);
288 }
289 }
290
291 foreach(EventToGenerate eventToGenerate in eventsToGenerate)
292 {
293 NestedClassEmitter add_nestedClass = method2Invocation[eventToGenerate.AddMethod];
294
295 MethodAttributes add_atts = ObtainMethodAttributes(eventToGenerate.AddMethod);
296
297 MethodEmitter addEmitter = eventToGenerate.Emitter.CreateAddMethod(add_atts);
298
299 ImplementProxiedMethod(targetType,
300 addEmitter,
301 eventToGenerate.AddMethod,
302 emitter,
303 add_nestedClass,
304 interceptorsField,
305 SelfReference.Self,
306 ConstructorVersion.WithoutTargetMethod,
307 null);
308
309 ReplicateNonInheritableAttributes(eventToGenerate.AddMethod, addEmitter);
310
311 NestedClassEmitter remove_nestedClass = method2Invocation[eventToGenerate.RemoveMethod];
312
313 MethodAttributes remove_atts = ObtainMethodAttributes(eventToGenerate.RemoveMethod);
314
315 MethodEmitter removeEmitter = eventToGenerate.Emitter.CreateRemoveMethod(remove_atts);
316
317 ImplementProxiedMethod(targetType,
318 removeEmitter,
319 eventToGenerate.RemoveMethod,
320 emitter,
321 remove_nestedClass,
322 interceptorsField,
323 SelfReference.Self,
324 ConstructorVersion.WithoutTargetMethod,
325 null);
326
327 ReplicateNonInheritableAttributes(eventToGenerate.RemoveMethod, removeEmitter);
328 }
329 }
330
331 protected MethodEmitter ImplementProxiedMethod(
332 Type targetType,
333 MethodEmitter methodEmitter,
334 MethodInfo method,
335 ClassEmitter emitter,
336 NestedClassEmitter invocationImpl,
337 FieldReference interceptorsField,
338 Reference targetRef,
339 ConstructorVersion version,
340 MethodInfo methodOnTarget)
341 {
342 CheckNotGenericTypeDefinition(targetType, "targetType");
343
344 methodEmitter.CopyParametersAndReturnTypeFrom(method, emitter);
345
346 TypeReference[] dereferencedArguments = IndirectReference.WrapIfByRef(methodEmitter.Arguments);
347
348 Type iinvocation = invocationImpl.TypeBuilder;
349
350 Trace.Assert(method.IsGenericMethod == iinvocation.IsGenericTypeDefinition);
351 bool isGenericInvocationClass = false;
352 Type[] genericMethodArgs = new Type[0];
353 if (method.IsGenericMethod)
354 {
355 // bind generic method arguments to invocation's type arguments
356 genericMethodArgs = methodEmitter.MethodBuilder.GetGenericArguments();
357 iinvocation = iinvocation.MakeGenericType(genericMethodArgs);
358 isGenericInvocationClass = true;
359 }
360
361 LocalReference invocationImplLocal = methodEmitter.CodeBuilder.DeclareLocal(iinvocation);
362
363 // TODO: Initialize iinvocation instance
364 // with ordinary arguments and in and out arguments
365
366 Expression interceptors;
367
368 // if (useSelector)
369 {
370 // TODO: Generate code that checks the return of selector
371 // if no interceptors is returned, should we invoke the base.Method directly?
372 }
373 // else
374 {
375 interceptors = interceptorsField.ToExpression();
376 }
377
378 Expression typeTokenFieldExp = typeTokenField.ToExpression();
379 Expression methodInfoTokenExp;
380
381 if (method2TokenField.ContainsKey(method)) // Token is in the cache
382 {
383 methodInfoTokenExp = ((FieldReference) method2TokenField[method]).ToExpression();
384 }
385 else
386 {
387 // Not in the cache: generic method
388
389 methodInfoTokenExp = new MethodTokenExpression(method.MakeGenericMethod(genericMethodArgs));
390 }
391
392 ConstructorInfo constructor = invocationImpl.Constructors[0].ConstructorBuilder;
393
394 if (isGenericInvocationClass)
395 {
396 constructor = TypeBuilder.GetConstructor(iinvocation, invocationImpl.Constructors[0].ConstructorBuilder);
397 }
398
399 NewInstanceExpression newInvocImpl;
400
401 if (version == ConstructorVersion.WithTargetMethod)
402 {
403 Expression methodOnTargetTokenExp;
404
405 if (method2TokenField.ContainsKey(methodOnTarget)) // Token is in the cache
406 {
407 methodOnTargetTokenExp = ((FieldReference) method2TokenField[methodOnTarget]).ToExpression();
408 }
409 else
410 {
411 // Not in the cache: generic method
412
413 methodOnTargetTokenExp = new MethodTokenExpression(methodOnTarget.MakeGenericMethod(genericMethodArgs));
414 }
415
416 newInvocImpl =
417 new NewInstanceExpression(constructor,
418 targetRef.ToExpression(),
419 interceptors,
420 typeTokenFieldExp,
421 methodOnTargetTokenExp,
422 methodInfoTokenExp,
423 new ReferencesToObjectArrayExpression(dereferencedArguments),
424 SelfReference.Self.ToExpression());
425 }
426 else
427 {
428 newInvocImpl =
429 new NewInstanceExpression(constructor,
430 targetRef.ToExpression(),
431 interceptors,
432 typeTokenFieldExp,
433 methodInfoTokenExp,
434 new ReferencesToObjectArrayExpression(dereferencedArguments),
435 SelfReference.Self.ToExpression());
436 }
437
438 methodEmitter.CodeBuilder.AddStatement(new AssignStatement(invocationImplLocal, newInvocImpl));
439
440 if (method.ContainsGenericParameters)
441 {
442 EmitLoadGenricMethodArguments(methodEmitter, method.MakeGenericMethod(genericMethodArgs), invocationImplLocal);
443 }
444
445 methodEmitter.CodeBuilder.AddStatement(
446 new ExpressionStatement(new MethodInvocationExpression(invocationImplLocal, Constants.AbstractInvocationProceed)));
447
448 CopyOutAndRefParameters(dereferencedArguments, invocationImplLocal, method, methodEmitter);
449
450 if (method.ReturnType != typeof(void))
451 {
452 // Emit code to return with cast from ReturnValue
453 MethodInvocationExpression getRetVal =
454 new MethodInvocationExpression(invocationImplLocal, typeof(AbstractInvocation).GetMethod("get_ReturnValue"));
455
456 methodEmitter.CodeBuilder.AddStatement(
457 new ReturnStatement(new ConvertExpression(methodEmitter.ReturnType, getRetVal)));
458 }
459 else
460 {
461 methodEmitter.CodeBuilder.AddStatement(new ReturnStatement());
462 }
463
464 return methodEmitter;
465 }
466
467 private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, MethodInfo method,
468 LocalReference invocationImplLocal)
469 {
470 Type[] genericParameters =
471 Array.FindAll(method.GetGenericArguments(), delegate(Type t) { return t.IsGenericParameter; });
472 LocalReference genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
473 methodEmitter.CodeBuilder.AddStatement(
474 new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Length, typeof(Type))));
475
476 for(int i = 0; i < genericParameters.Length; ++i)
477 {
478 methodEmitter.CodeBuilder.AddStatement(
479 new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
480 }
481 MethodInfo setGenericsArgs =
482 typeof(AbstractInvocation).GetMethod("SetGenericMethodArguments", new Type[] {typeof(Type[])});
483 methodEmitter.CodeBuilder.AddStatement(new ExpressionStatement(
484 new MethodInvocationExpression(invocationImplLocal, setGenericsArgs,
485 new ReferenceExpression(
486 genericParamsArrayLocal))));
487 }
488
489 private static void CopyOutAndRefParameters(
490 TypeReference[] dereferencedArguments, LocalReference invocationImplLocal, MethodInfo method,
491 MethodEmitter methodEmitter)
492 {
493 ParameterInfo[] parameters = method.GetParameters();
494 bool hasByRefParam = false;
495 for(int i = 0; i < parameters.Length; i++)
496 {
497 if (parameters[i].ParameterType.IsByRef)
498 hasByRefParam = true;
499 }
500 if (!hasByRefParam)
501 return; //saving the need to create locals if there is no need
502 LocalReference invocationArgs = methodEmitter.CodeBuilder.DeclareLocal(typeof(object[]));
503 methodEmitter.CodeBuilder.AddStatement(
504 new AssignStatement(invocationArgs,
505 new MethodInvocationExpression(invocationImplLocal, invocation_getArgumentsMethod)
506 )
507 );
508 for(int i = 0; i < parameters.Length; i++)
509 {
510 if (parameters[i].ParameterType.IsByRef)
511 {
512 methodEmitter.CodeBuilder.AddStatement(
513 new AssignStatement(dereferencedArguments[i],
514 new ConvertExpression(dereferencedArguments[i].Type,
515 new LoadRefArrayElementExpression(i, invocationArgs)
516 )
517 ));
518 }
519 }
520 }
521
522 protected void GenerateConstructor(ClassEmitter emitter, params FieldReference[] fields)
523 {
524 GenerateConstructor(emitter, null, fields);
525 }
526
527 protected void GenerateConstructor(
528 ClassEmitter emitter, ConstructorInfo baseConstructor, params FieldReference[] fields)
529 {
530 ArgumentReference[] args;
531 ParameterInfo[] baseConstructorParams = null;
532
533 if (baseConstructor != null)
534 {
535 baseConstructorParams = baseConstructor.GetParameters();
536 }
537
538 if (baseConstructorParams != null && baseConstructorParams.Length != 0)
539 {
540 args = new ArgumentReference[fields.Length + baseConstructorParams.Length];
541
542 int offset = fields.Length;
543
544 for(int i = offset; i < offset + baseConstructorParams.Length; i++)
545 {
546 ParameterInfo paramInfo = baseConstructorParams[i - offset];
547 args[i] = new ArgumentReference(paramInfo.ParameterType);
548 }
549 }
550 else
551 {
552 args = new ArgumentReference[fields.Length];
553 }
554
555 for(int i = 0; i < fields.Length; i++)
556 {
557 args[i] = new ArgumentReference(fields[i].Reference.FieldType);
558 }
559
560 ConstructorEmitter constructor = emitter.CreateConstructor(args);
561
562 for(int i = 0; i < fields.Length; i++)
563 {
564 constructor.CodeBuilder.AddStatement(new AssignStatement(fields[i], args[i].ToExpression()));
565 }
566
567 // Invoke base constructor
568
569 if (baseConstructor != null)
570 {
571 ArgumentReference[] slice = new ArgumentReference[baseConstructorParams.Length];
572 Array.Copy(args, fields.Length, slice, 0, baseConstructorParams.Length);
573
574 constructor.CodeBuilder.InvokeBaseConstructor(baseConstructor, slice);
575 }
576 else
577 {
578 constructor.CodeBuilder.InvokeBaseConstructor();
579 }
580
581 // Invoke initialize method
582
583 // constructor.CodeBuilder.AddStatement(
584 // new ExpressionStatement(new MethodInvocationExpression(SelfReference.Self, initCacheMethod)));
585
586 constructor.CodeBuilder.AddStatement(new ReturnStatement());
587 }
588
589 /// <summary>
590 /// Generates a parameters constructor that initializes the proxy
591 /// state with <see cref="StandardInterceptor"/> just to make it non-null.
592 /// <para>
593 /// This constructor is important to allow proxies to be XML serializable
594 /// </para>
595 /// </summary>
596 protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseClass, FieldReference interceptorField)
597 {
598 // Check if the type actually has a default constructor
599
600 ConstructorInfo defaultConstructor = baseClass.GetConstructor(BindingFlags.Public, null, Type.EmptyTypes, null);
601
602 if (defaultConstructor == null)
603 {
604 defaultConstructor = baseClass.GetConstructor(BindingFlags.NonPublic, null, Type.EmptyTypes, null);
605
606 if (defaultConstructor == null || defaultConstructor.IsPrivate)
607 {
608 return;
609 }
610 }
611
612 ConstructorEmitter constructor = emitter.CreateConstructor();
613
614 // initialize fields with an empty interceptor
615
616 constructor.CodeBuilder.AddStatement(
617 new AssignStatement(interceptorField, new NewArrayExpression(1, typeof(IInterceptor))));
618 constructor.CodeBuilder.AddStatement(
619 new AssignArrayStatement(interceptorField, 0, new NewInstanceExpression(typeof(StandardInterceptor), new Type[0])));
620
621 // Invoke base constructor
622
623 constructor.CodeBuilder.InvokeBaseConstructor(defaultConstructor);
624
625 constructor.CodeBuilder.AddStatement(new ReturnStatement());
626 }
627
628 #region First level attributes
629
630 protected MethodAttributes ObtainMethodAttributes(MethodInfo method)
631 {
632 MethodAttributes atts = MethodAttributes.Virtual;
633
634 if (ShouldCreateNewSlot(method))
635 {
636 atts |= MethodAttributes.NewSlot;
637 }
638
639 if (method.IsPublic)
640 {
641 atts |= MethodAttributes.Public;
642 }
643
644 if (method.IsHideBySig)
645 {
646 atts |= MethodAttributes.HideBySig;
647 }
648 if (InternalsHelper.IsInternal(method) && InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly))
649 {
650 atts |= MethodAttributes.Assembly;
651 }
652 if (method.IsFamilyAndAssembly)
653 {
654 atts |= MethodAttributes.FamANDAssem;
655 }
656 else if (method.IsFamilyOrAssembly)
657 {
658 atts |= MethodAttributes.FamORAssem;
659 }
660 else if (method.IsFamily)
661 {
662 atts |= MethodAttributes.Family;
663 }
664
665 if (method.Name.StartsWith("set_") || method.Name.StartsWith("get_"))
666 {
667 atts |= MethodAttributes.SpecialName;
668 }
669
670 return atts;
671 }
672
673 private PropertyAttributes ObtainPropertyAttributes(PropertyInfo property)
674 {
675 PropertyAttributes atts = PropertyAttributes.None;
676
677 return atts;
678 }
679
680 #endregion
681
682 protected MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodInfo, MethodInfo methodOnTarget)
683 {
684 MethodInfo targetMethod = methodOnTarget != null ? methodOnTarget : methodInfo;
685
686 if (targetMethod.IsAbstract)
687 return null;
688
689 // MethodBuild creation
690
691 MethodAttributes atts = MethodAttributes.Family;
692
693 String name = methodInfo.Name + "_callback_" + ++callbackCounter;
694
695 MethodEmitter callBackMethod = emitter.CreateMethod(name, atts);
696
697 callBackMethod.CopyParametersAndReturnTypeFrom(targetMethod, emitter);
698
699 // Generic definition
700
701 if (targetMethod.IsGenericMethod)
702 {
703 targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams);
704 }
705
706 // Parameters exp
707
708 Expression[] exps = new Expression[callBackMethod.Arguments.Length];
709
710 for(int i = 0; i < callBackMethod.Arguments.Length; i++)
711 {
712 exps[i] = callBackMethod.Arguments[i].ToExpression();
713 }
714
715 // invocation on base class
716
717 callBackMethod.CodeBuilder.AddStatement(
718 new ReturnStatement(new MethodInvocationExpression(GetProxyTargetReference(), targetMethod, exps)));
719
720 return callBackMethod.MethodBuilder;
721 }
722
723 #region IInvocation related
724
725 /// <summary>
726 /// If callbackMethod is null the InvokeOnTarget implementation
727 /// is just the code to throw an exception
728 /// </summary>
729 /// <param name="emitter"></param>
730 /// <param name="targetType"></param>
731 /// <param name="targetForInvocation"></param>
732 /// <param name="methodInfo"></param>
733 /// <param name="callbackMethod"></param>
734 /// <param name="version"></param>
735 /// <returns></returns>
736 protected NestedClassEmitter BuildInvocationNestedType(
737 ClassEmitter emitter,
738 Type targetType,
739 Type targetForInvocation,
740 MethodInfo methodInfo,
741 MethodInfo callbackMethod,
742 ConstructorVersion version)
743 {
744 CheckNotGenericTypeDefinition(targetType, "targetType");
745 CheckNotGenericTypeDefinition(targetForInvocation, "targetForInvocation");
746 return
747 BuildInvocationNestedType(emitter, targetType, targetForInvocation, methodInfo, callbackMethod, version, false);
748 }
749
750 /// <summary>
751 /// If callbackMethod is null the InvokeOnTarget implementation
752 /// is just the code to throw an exception
753 /// </summary>
754 /// <param name="emitter"></param>
755 /// <param name="targetType"></param>
756 /// <param name="targetForInvocation"></param>
757 /// <param name="methodInfo"></param>
758 /// <param name="callbackMethod"></param>
759 /// <param name="version"></param>
760 /// <param name="allowChangeTarget">If true the invocation will implement the IChangeProxyTarget interface</param>
761 /// <returns></returns>
762 protected NestedClassEmitter BuildInvocationNestedType(
763 ClassEmitter emitter,
764 Type targetType,
765 Type targetForInvocation,
766 MethodInfo methodInfo,
767 MethodInfo callbackMethod,
768 ConstructorVersion version,
769 bool allowChangeTarget)
770 {
771 CheckNotGenericTypeDefinition(targetType, "targetType");
772 CheckNotGenericTypeDefinition(targetForInvocation, "targetForInvocation");
773
774 nestedCounter++;
775
776 Type[] interfaces = new Type[0];
777
778 if (allowChangeTarget)
779 {
780 interfaces = new Type[] {typeof(IChangeProxyTarget)};
781 }
782
783 NestedClassEmitter nested =
784 new NestedClassEmitter(emitter,
785 "Invocation" + methodInfo.Name + "_" + nestedCounter.ToString(),
786 typeof(AbstractInvocation),
787 interfaces);
788
789 // invocation only needs to mirror the generic parameters of the MethodInfo
790 // targetType cannot be a generic type definition
791 nested.CreateGenericParameters(methodInfo.GetGenericArguments());
792
793 // Create the invocation fields
794
795 FieldReference targetRef = nested.CreateField("target", targetForInvocation);
796
797 // Create constructor
798
799 CreateIInvocationConstructor(targetForInvocation, nested, targetRef, version);
800
801 if (allowChangeTarget)
802 {
803 ArgumentReference argument1 = new ArgumentReference(typeof(object));
804 MethodEmitter methodEmitter =
805 nested.CreateMethod("ChangeInvocationTarget", MethodAttributes.Public | MethodAttributes.Virtual,
806 typeof(void), argument1);
807 methodEmitter.CodeBuilder.AddStatement(
808 new AssignStatement(targetRef,
809 new ConvertExpression(targetType, argument1.ToExpression())
810 )
811 );
812 methodEmitter.CodeBuilder.AddStatement(new ReturnStatement());
813 }
814
815 // InvokeMethodOnTarget implementation
816
817 if (callbackMethod != null)
818 {
819 ParameterInfo[] parameters = methodInfo.GetParameters();
820
821 CreateIInvocationInvokeOnTarget(emitter, nested, parameters, targetRef, callbackMethod);
822 }
823 else
824 {
825 CreateEmptyIInvocationInvokeOnTarget(nested);
826 }
827
828 nested.DefineCustomAttribute(new SerializableAttribute());
829
830 return nested;
831 }
832
833 protected void CreateIInvocationInvokeOnTarget(
834 ClassEmitter targetTypeEmitter,
835 NestedClassEmitter nested,
836 ParameterInfo[] parameters,
837 FieldReference targetField,
838 MethodInfo callbackMethod)
839 {
840 const MethodAttributes methodAtts = MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual;
841
842 MethodEmitter method =
843 nested.CreateMethod ("InvokeMethodOnTarget", methodAtts, typeof (void));
844
845 Expression[] args = new Expression[parameters.Length];
846
847 // Idea: instead of grab parameters one by one
848 // we should grab an array
849 Hashtable byRefArguments = new Hashtable();
850
851 for(int i = 0; i < parameters.Length; i++)
852 {
853 ParameterInfo param = parameters[i];
854
855 Type paramType = param.ParameterType;
856
857 if (HasGenericParameters(paramType))
858 {
859 paramType = paramType.GetGenericTypeDefinition().MakeGenericType(nested.GetGenericArgumentsFor(paramType));
860 }
861 else if (paramType.IsGenericParameter)
862 {
863 paramType = nested.GetGenericArgument(paramType.Name);
864 }
865
866 if (paramType.IsByRef)
867 {
868 LocalReference localReference = method.CodeBuilder.DeclareLocal(paramType.GetElementType());
869 method.CodeBuilder.AddStatement(
870 new AssignStatement(localReference,
871 new ConvertExpression(paramType.GetElementType(),
872 new MethodInvocationExpression(SelfReference.Self,
873 typeof(AbstractInvocation).GetMethod(
874 "GetArgumentValue"),
875 new LiteralIntExpression(i)))));
876 ByRefReference byRefReference = new ByRefReference(localReference);
877 args[i] = new ReferenceExpression(byRefReference);
878 byRefArguments[i] = localReference;
879 }
880 else
881 {
882 args[i] =
883 new ConvertExpression(paramType,
884 new MethodInvocationExpression(SelfReference.Self,
885 typeof(AbstractInvocation).GetMethod("GetArgumentValue"),
886 new LiteralIntExpression(i)));
887 }
888 }
889
890 MethodInvocationExpression baseMethodInvExp;
891
892 if (callbackMethod.IsGenericMethod)
893 {
894 callbackMethod = callbackMethod.MakeGenericMethod(nested.GetGenericArgumentsFor(callbackMethod));
895 }
896
897 baseMethodInvExp = new MethodInvocationExpression(targetField, callbackMethod, args);
898 baseMethodInvExp.VirtualCall = true;
899
900 LocalReference ret_local = null;
901
902 if (callbackMethod.ReturnType != typeof(void))
903 {
904 if (callbackMethod.ReturnType.IsGenericParameter)
905 {
906 ret_local = method.CodeBuilder.DeclareLocal(nested.GetGenericArgument(callbackMethod.ReturnType.Name));
907 }
908 else if (HasGenericParameters(callbackMethod.ReturnType))
909 {
910 ret_local =
911 method.CodeBuilder.DeclareLocal(
912 callbackMethod.ReturnType.GetGenericTypeDefinition().MakeGenericType(
913 nested.GetGenericArgumentsFor(callbackMethod.ReturnType)));
914 }
915 else
916 {
917 ret_local = method.CodeBuilder.DeclareLocal(callbackMethod.ReturnType);
918 }
919
920 method.CodeBuilder.AddStatement(new AssignStatement(ret_local, baseMethodInvExp));
921 }
922 else
923 {
924 method.CodeBuilder.AddStatement(new ExpressionStatement(baseMethodInvExp));
925 }
926
927 foreach(DictionaryEntry byRefArgument in byRefArguments)
928 {
929 int index = (int) byRefArgument.Key;
930 LocalReference localReference = (LocalReference) byRefArgument.Value;
931 method.CodeBuilder.AddStatement(
932 new ExpressionStatement(
933 new MethodInvocationExpression(SelfReference.Self,
934 typeof(AbstractInvocation).GetMethod("SetArgumentValue"),
935 new LiteralIntExpression(index),
936 new ConvertExpression(typeof(object), localReference.Type,
937 new ReferenceExpression(localReference)))
938 ));
939 }
940
941 if (callbackMethod.ReturnType != typeof(void))
942 {
943 MethodInvocationExpression setRetVal =
944 new MethodInvocationExpression(SelfReference.Self,
945 typeof(AbstractInvocation).GetMethod("set_ReturnValue"),
946 new ConvertExpression(typeof(object), ret_local.Type, ret_local.ToExpression()));
947
948 method.CodeBuilder.AddStatement(new ExpressionStatement(setRetVal));
949 }
950
951 method.CodeBuilder.AddStatement(new ReturnStatement());
952 }
953
954 protected void CreateEmptyIInvocationInvokeOnTarget(NestedClassEmitter nested)
955 {
956 const MethodAttributes methodAtts = MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual;
957
958 MethodEmitter method =
959 nested.CreateMethod("InvokeMethodOnTarget", methodAtts, typeof(void));
960
961 // TODO: throw exception
962
963 String message =
964 String.Format("This is a DynamicProxy2 error: the interceptor attempted " +
965 "to 'Proceed' for a method without a target, for example, an interface method or an abstract method");
966
967 method.CodeBuilder.AddStatement(new ThrowStatement(typeof(NotImplementedException), message));
968
969 method.CodeBuilder.AddStatement(new ReturnStatement());
970 }
971
972 /// <summary>
973 /// Generates the constructor for the nested class that extends
974 /// <see cref="AbstractInvocation"/>
975 /// </summary>
976 /// <param name="targetFieldType"></param>
977 /// <param name="nested"></param>
978 /// <param name="targetField"></param>
979 /// <param name="version"></param>
980 protected void CreateIInvocationConstructor(
981 Type targetFieldType, NestedClassEmitter nested, FieldReference targetField, ConstructorVersion version)
982 {
983 ArgumentReference cArg0 = new ArgumentReference(targetFieldType);
984 ArgumentReference cArg1 = new ArgumentReference(typeof(IInterceptor[]));
985 ArgumentReference cArg2 = new ArgumentReference(typeof(Type));
986 ArgumentReference cArg3 = new ArgumentReference(typeof(MethodInfo));
987 ArgumentReference cArg4 = null;
988 ArgumentReference cArg6 = new ArgumentReference(typeof(object));
989
990 if (version == ConstructorVersion.WithTargetMethod)
991 {
992 cArg4 = new ArgumentReference(typeof(MethodInfo));
993 }
994
995 ArgumentReference cArg5 = new ArgumentReference(typeof(object[]));
996
997 ConstructorEmitter constructor;
998
999 if (cArg4 == null)
1000 {
1001 constructor = nested.CreateConstructor(cArg0, cArg1, cArg2, cArg3, cArg5, cArg6);
1002 }
1003 else
1004 {
1005 constructor = nested.CreateConstructor(cArg0, cArg1, cArg2, cArg3, cArg4, cArg5, cArg6);
1006 }
1007
1008 constructor.CodeBuilder.AddStatement(new AssignStatement(targetField, cArg0.ToExpression()));
1009
1010 if (cArg4 == null)
1011 {
1012 constructor.CodeBuilder.InvokeBaseConstructor(Constants.AbstractInvocationConstructorWithoutTargetMethod,
1013 cArg0,
1014 cArg6,
1015 cArg1,
1016 cArg2,
1017 cArg3,
1018 cArg5);
1019 }
1020 else
1021 {
1022 constructor.CodeBuilder.InvokeBaseConstructor(Constants.AbstractInvocationConstructorWithTargetMethod,
1023 cArg0,
1024 cArg6,
1025 cArg1,
1026 cArg2,
1027 cArg3,
1028 cArg4,
1029 cArg5);
1030 }
1031
1032 constructor.CodeBuilder.AddStatement(new ReturnStatement());
1033 }
1034
1035 #endregion
1036
1037 #region Custom Attribute handling
1038
1039 protected void ReplicateNonInheritableAttributes(Type targetType, ClassEmitter emitter)
1040 {
1041 object[] attrs = targetType.GetCustomAttributes(false);
1042
1043 foreach(Attribute attribute in attrs)
1044 {
1045 if (ShouldSkipAttributeReplication(attribute)) continue;
1046
1047 emitter.DefineCustomAttribute(attribute);
1048 }
1049 }
1050
1051 protected void ReplicateNonInheritableAttributes(MethodInfo method, MethodEmitter emitter)
1052 {
1053 object[] attrs = method.GetCustomAttributes(false);
1054
1055 foreach(Attribute attribute in attrs)
1056 {
1057 if (ShouldSkipAttributeReplication(attribute)) continue;
1058
1059 emitter.DefineCustomAttribute(attribute);
1060 }
1061 }
1062
1063 #endregion
1064
1065 #region Type tokens related operations
1066
1067 protected void GenerateConstructors(ClassEmitter emitter, Type baseType, params FieldReference[] fields)
1068 {
1069 ConstructorInfo[] constructors =
1070 baseType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
1071
1072 foreach(ConstructorInfo constructor in constructors)
1073 {
1074 if (constructor.IsPublic || constructor.IsFamily
1075 || (constructor.IsAssembly && InternalsHelper.IsInternalToDynamicProxy(constructor.DeclaringType.Assembly)))
1076 GenerateConstructor(emitter, constructor, fields);
1077 }
1078 }
1079
1080 protected ConstructorEmitter GenerateStaticConstructor(ClassEmitter emitter)
1081 {
1082 return emitter.CreateTypeConstructor();
1083 }
1084
1085 /// <summary>
1086 /// Improvement: this cache should be static. We should generate a
1087 /// type constructor instead
1088 /// </summary>
1089 protected void CreateInitializeCacheMethodBody(
1090 Type targetType, MethodInfo[] methods, ClassEmitter classEmitter, ConstructorEmitter typeInitializerConstructor)
1091 {
1092 typeTokenField = classEmitter.CreateStaticField("typeTokenCache", typeof(Type));
1093
1094 typeInitializerConstructor.CodeBuilder.AddStatement(
1095 new AssignStatement(typeTokenField, new TypeTokenExpression(targetType)));
1096
1097 CacheMethodTokens(classEmitter, methods, typeInitializerConstructor);
1098 }
1099
1100 protected void CacheMethodTokens(
1101 ClassEmitter classEmitter, MethodInfo[] methods, ConstructorEmitter typeInitializerConstructor)
1102 {
1103 foreach(MethodInfo method in methods)
1104 {
1105 // Aparently we cannot cache generic methods
1106 if (method.IsGenericMethod) continue;
1107
1108 AddFieldToCacheMethodTokenAndStatementsToInitialize(method, typeInitializerConstructor, classEmitter);
1109 }
1110 }
1111
1112 protected void AddFieldToCacheMethodTokenAndStatementsToInitialize(
1113 MethodInfo method, ConstructorEmitter typeInitializerConstructor, ClassEmitter classEmitter)
1114 {
1115 if (!method2TokenField.ContainsKey(method))
1116 {
1117 FieldReference fieldCache =
1118 classEmitter.CreateStaticField("tokenCache" + fieldCount++, typeof(MethodInfo));
1119
1120 method2TokenField.Add(method, fieldCache);
1121
1122 typeInitializerConstructor.CodeBuilder.AddStatement(
1123 new AssignStatement(fieldCache, new MethodTokenExpression(method)));
1124 }
1125 }
1126
1127 protected void CompleteInitCacheMethod(ConstructorCodeBuilder constCodeBuilder)
1128 {
1129 constCodeBuilder.AddStatement(new ReturnStatement());
1130 }
1131
1132 protected void AddDefaultInterfaces(IList interfaceList)
1133 {
1134 if (!interfaceList.Contains(typeof(IProxyTargetAccessor)))
1135 {
1136 interfaceList.Add(typeof(IProxyTargetAccessor));
1137 }
1138 }
1139
1140 protected void ImplementProxyTargetAccessor(Type targetType, ClassEmitter emitter, FieldReference interceptorsField)
1141 {
1142 MethodAttributes attributes = MethodAttributes.Virtual | MethodAttributes.Public;
1143
1144 MethodEmitter DynProxyGetTarget =
1145 emitter.CreateMethod("DynProxyGetTarget", attributes, typeof (object));
1146
1147 DynProxyGetTarget.CodeBuilder.AddStatement(
1148 new ReturnStatement(new ConvertExpression(typeof (object), targetType, GetProxyTargetReference().ToExpression())));
1149
1150 MethodEmitter GetInterceptors =
1151 emitter.CreateMethod("GetInterceptors", attributes, typeof (IInterceptor[]));
1152
1153 GetInterceptors.CodeBuilder.AddStatement(
1154 new ReturnStatement(interceptorsField)
1155 );
1156
1157 }
1158
1159 #endregion
1160
1161 #region Utility methods
1162
1163 protected void CollectMethodsToProxy(ArrayList methodList, Type type, bool onlyVirtuals)
1164 {
1165 CollectMethods(methodList, type, onlyVirtuals);
1166
1167 if (type.IsInterface)
1168 {
1169 Type[] typeChain = type.FindInterfaces(new TypeFilter(NoFilter), null);
1170
1171 foreach(Type interType in typeChain)
1172 {
1173 CollectMethods(methodList, interType, onlyVirtuals);
1174 }
1175 }
1176 }
1177
1178 protected void CollectPropertyMethodsToProxy(
1179 ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter, out PropertyToGenerate[] propsToGenerate)
1180 {
1181 if (type.IsInterface)
1182 {
1183 ArrayList toGenerateList = new ArrayList();
1184
1185 toGenerateList.AddRange(CollectProperties(methodList, type, onlyVirtuals, emitter));
1186
1187 Type[] typeChain = type.FindInterfaces(new TypeFilter(NoFilter), null);
1188
1189 foreach(Type interType in typeChain)
1190 {
1191 toGenerateList.AddRange(CollectProperties(methodList, interType, onlyVirtuals, emitter));
1192 }
1193
1194 propsToGenerate = (PropertyToGenerate[]) toGenerateList.ToArray(typeof(PropertyToGenerate));
1195 }
1196 else
1197 {
1198 propsToGenerate = CollectProperties(methodList, type, onlyVirtuals, emitter);
1199 }
1200 }
1201
1202 /// <summary>
1203 /// Performs some basic screening and invokes the <see cref="IProxyGenerationHook"/>
1204 /// to select methods.
1205 /// </summary>
1206 /// <param name="method"></param>
1207 /// <param name="onlyVirtuals"></param>
1208 /// <returns></returns>
1209 protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals)
1210 {
1211 // we can never intercept a sealed (final) method
1212 if (method.IsFinal)
1213 return false;
1214
1215 bool isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternal(method);
1216 if (isInternalsAndNotVisibleToDynamicProxy)
1217 {
1218 isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly) ==
1219 false;
1220 }
1221
1222 if (isInternalsAndNotVisibleToDynamicProxy)
1223 return false;
1224
1225 if (onlyVirtuals && !method.IsVirtual)
1226 {
1227 if (method.DeclaringType != typeof(object) && method.DeclaringType != typeof(MarshalByRefObject))
1228 {
1229 ProxyGenerationOptions.Hook.NonVirtualMemberNotification(targetType, method);
1230 }
1231
1232 return false;
1233 }
1234
1235 //can only proxy methods that are public or protected (or internals that have already been checked above)
1236 if ((method.IsPublic || method.IsFamily || method.IsAssembly || method.IsFamilyOrAssembly) == false)
1237 return false;
1238
1239 if (method.DeclaringType == typeof(object))
1240 {
1241 return false;
1242 }
1243 if (method.DeclaringType == typeof(MarshalByRefObject))
1244 {
1245 return false;
1246 }
1247
1248 return ProxyGenerationOptions.Hook.ShouldInterceptMethod(targetType, method);
1249 ;
1250 }
1251
1252 protected MethodInfo[] CollectMethodsAndProperties(
1253 ClassEmitter emitter,
1254 Type targetType,
1255 out PropertyToGenerate[] propsToGenerate,
1256 out EventToGenerate[] eventsToGenerate)
1257 {
1258 bool onlyVirtuals = CanOnlyProxyVirtual();
1259
1260 return CollectMethodsAndProperties(emitter, targetType, onlyVirtuals, out propsToGenerate, out eventsToGenerate);
1261 }
1262
1263 protected MethodInfo[] CollectMethodsAndProperties(
1264 ClassEmitter emitter,
1265 Type targetType,
1266 bool onlyVirtuals,
1267 out PropertyToGenerate[] propsToGenerate,
1268 out EventToGenerate[] eventsToGenerate)
1269 {
1270 ArrayList methodsList = new ArrayList();
1271
1272 CollectMethodsToProxy(methodsList, targetType, onlyVirtuals);
1273 CollectPropertyMethodsToProxy(methodsList, targetType, onlyVirtuals, emitter, out propsToGenerate);
1274 CollectEventMethodsToProxy(methodsList, targetType, onlyVirtuals, emitter, out eventsToGenerate);
1275 return (MethodInfo[]) methodsList.ToArray(typeof(MethodInfo));
1276 }
1277
1278 private void CollectEventMethodsToProxy(
1279 ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter, out EventToGenerate[] eventsToGenerates)
1280 {
1281 if (type.IsInterface)
1282 {
1283 ArrayList toGenerateList = new ArrayList();
1284
1285 toGenerateList.AddRange(CollectEvents(methodList, type, onlyVirtuals, emitter));
1286
1287 Type[] typeChain = type.FindInterfaces(new TypeFilter(NoFilter), null);
1288
1289 foreach(Type interType in typeChain)
1290 {
1291 toGenerateList.AddRange(CollectEvents(methodList, interType, onlyVirtuals, emitter));
1292 }
1293
1294 eventsToGenerates = (EventToGenerate[]) toGenerateList.ToArray(typeof(EventToGenerate));
1295 }
1296 else
1297 {
1298 eventsToGenerates = CollectEvents(methodList, type, onlyVirtuals, emitter);
1299 }
1300 }
1301
1302 /// <summary>
1303 /// Checks if the method is public or protected.
1304 /// </summary>
1305 /// <param name="method"></param>
1306 /// <returns></returns>
1307 private bool IsAccessible(MethodInfo method)
1308 {
1309 if (method.IsPublic
1310 || method.IsFamily
1311 || method.IsFamilyAndAssembly
1312 || method.IsFamilyOrAssembly)
1313 {
1314 return true;
1315 }
1316
1317 if (InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly)
1318 && method.IsAssembly)
1319 {
1320 return true;
1321 }
1322
1323 return false;
1324 }
1325
1326 private bool HasGenericParameters(Type type)
1327 {
1328 if (type.IsGenericType)
1329 {
1330 Type[] genTypes = type.GetGenericArguments();
1331
1332 foreach(Type genType in genTypes)
1333 {
1334 if (genType.IsGenericParameter)
1335 {
1336 return true;
1337 }
1338 }
1339 }
1340
1341 return false;
1342 }
1343
1344 private bool NoFilter(Type type, object filterCriteria)
1345 {
1346 return true;
1347 }
1348
1349 private void CollectMethods(ArrayList methodsList, Type type, bool onlyVirtuals)
1350 {
1351 BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
1352
1353 MethodInfo[] methods = MethodFinder.GetAllInstanceMethods(type, flags);
1354
1355 foreach(MethodInfo method in methods)
1356 {
1357 if (method.IsFinal)
1358 {
1359 AddMethodToGenerateNewSlot(method);
1360 continue;
1361 }
1362
1363 if (method.IsSpecialName
1364 // This is here so we can proxy COM Types built in VB6, where properties
1365 // are let_Foo and set_Foo.
1366 && method.Name.StartsWith("let_") == false)
1367 {
1368 continue;
1369 }
1370
1371 if (AcceptMethod(method, onlyVirtuals))
1372 {
1373 methodsList.Add(method);
1374 }
1375 }
1376 }
1377
1378 private EventToGenerate[] CollectEvents(ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter)
1379 {
1380 ArrayList toGenerateList = new ArrayList();
1381
1382 BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
1383
1384 EventInfo[] events = type.GetEvents(flags);
1385
1386 foreach(EventInfo eventInfo in events)
1387 {
1388 MethodInfo addMethod = eventInfo.GetAddMethod(true);
1389 MethodInfo removeMethod = eventInfo.GetRemoveMethod(true);
1390 bool shouldGenerate = false;
1391
1392 if (addMethod != null && IsAccessible(addMethod) && AcceptMethod(addMethod, onlyVirtuals))
1393 {
1394 shouldGenerate = true;
1395 methodList.Add(addMethod);
1396 }
1397
1398 if (removeMethod != null && IsAccessible(removeMethod) && AcceptMethod(removeMethod, onlyVirtuals))
1399 {
1400 shouldGenerate = true;
1401 methodList.Add(removeMethod);
1402 }
1403
1404 if (shouldGenerate == false)
1405 continue;
1406
1407 EventAttributes atts = ObtainEventAttributes(eventInfo);
1408
1409 EventEmitter eventEmitter = emitter.CreateEvent(eventInfo.Name, atts, eventInfo.EventHandlerType);
1410
1411 EventToGenerate eventToGenerate = new EventToGenerate(eventEmitter, addMethod, removeMethod, atts);
1412
1413 toGenerateList.Add(eventToGenerate);
1414 }
1415
1416 return (EventToGenerate[]) toGenerateList.ToArray(typeof(EventToGenerate));
1417 }
1418
1419 private EventAttributes ObtainEventAttributes(EventInfo eventInfo)
1420 {
1421 return EventAttributes.None;
1422 }
1423
1424 private PropertyToGenerate[] CollectProperties(
1425 ArrayList methodList, Type type, bool onlyVirtuals, ClassEmitter emitter)
1426 {
1427 ArrayList toGenerateList = new ArrayList();
1428
1429 BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
1430
1431 PropertyInfo[] properties = type.GetProperties(flags);
1432
1433 foreach(PropertyInfo propInfo in properties)
1434 {
1435 bool generateReadable, generateWritable;
1436
1437 generateWritable = generateReadable = false;
1438
1439 MethodInfo setMethod, getMethod;
1440 setMethod = getMethod = null;
1441
1442 if (propInfo.CanRead)
1443 {
1444 getMethod = propInfo.GetGetMethod(true);
1445
1446 if (IsAccessible(getMethod) && AcceptMethod(getMethod, onlyVirtuals))
1447 {
1448 methodList.Add(getMethod);
1449 generateReadable = true;
1450 }
1451 }
1452
1453 if (propInfo.CanWrite)
1454 {
1455 setMethod = propInfo.GetSetMethod(true);
1456
1457 if (IsAccessible(setMethod) && AcceptMethod(setMethod, onlyVirtuals))
1458 {
1459 methodList.Add(setMethod);
1460 generateWritable = true;
1461 }
1462 }
1463
1464 if (!generateWritable && !generateReadable)
1465 {
1466 continue;
1467 }
1468
1469 PropertyAttributes atts = ObtainPropertyAttributes(propInfo);
1470
1471 PropertyEmitter propEmitter = emitter.CreateProperty(propInfo.Name, atts, propInfo.PropertyType);
1472
1473 PropertyToGenerate propToGenerate =
1474 new PropertyToGenerate(generateReadable, generateWritable, propEmitter, getMethod, setMethod);
1475
1476 toGenerateList.Add(propToGenerate);
1477 }
1478
1479 return (PropertyToGenerate[]) toGenerateList.ToArray(typeof(PropertyToGenerate));
1480 }
1481
1482 /// <summary>
1483 /// Attributes should be replicated if they are non-inheritable,
1484 /// but there are some special cases where the attributes means
1485 /// something to the CLR, where they should be skipped.
1486 /// </summary>
1487 private bool ShouldSkipAttributeReplication(Attribute attribute)
1488 {
1489 if (SpecialCaseAttributThatShouldNotBeReplicated(attribute))
1490 return true;
1491
1492 object[] attrs = attribute.GetType()
1493 .GetCustomAttributes(typeof(AttributeUsageAttribute), true);
1494
1495 if (attrs.Length != 0)
1496 {
1497 AttributeUsageAttribute usage = (AttributeUsageAttribute) attrs[0];
1498
1499 return usage.Inherited;
1500 }
1501
1502 return true;
1503 }
1504
1505 #endregion
1506
1507 protected void AddMethodToGenerateNewSlot(MethodInfo method)
1508 {
1509 generateNewSlot.Add(method);
1510 }
1511
1512 /// <summary>
1513 /// Checks if the method has the same signature as a method that was marked as
1514 /// one that should generate a new vtable slot.
1515 /// </summary>
1516 protected bool ShouldCreateNewSlot(MethodInfo method)
1517 {
1518 string methodStr = method.ToString();
1519 foreach(MethodInfo candidate in generateNewSlot)
1520 {
1521 if (candidate.ToString() == methodStr)
1522 return true;
1523 }
1524 return false;
1525 }
1526
1527 protected virtual void ImplementGetObjectData(ClassEmitter emitter, FieldReference interceptorsField,
1528 Type[] interfaces)
1529 {
1530 if (interfaces == null)
1531 {
1532 interfaces = new Type[0];
1533 }
1534
1535 Type[] get_type_args = new Type[] {typeof(String), typeof(bool), typeof(bool)};
1536 Type[] key_and_object = new Type[] {typeof(String), typeof(Object)};
1537 MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object);
1538
1539 ArgumentReference arg1 = new ArgumentReference(typeof(SerializationInfo));
1540 ArgumentReference arg2 = new ArgumentReference(typeof(StreamingContext));
1541 MethodEmitter getObjectData = emitter.CreateMethod("GetObjectData",
1542 typeof(void), arg1, arg2);
1543
1544 LocalReference typeLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(Type));
1545
1546 getObjectData.CodeBuilder.AddStatement(new AssignStatement(
1547 typeLocal,
1548 new MethodInvocationExpression(null,
1549 typeof(Type).GetMethod("GetType",
1550 get_type_args),
1551 new ConstReference(
1552 typeof(ProxyObjectReference).
1553 AssemblyQualifiedName).ToExpression(),
1554 new ConstReference(1).ToExpression(),
1555 new ConstReference(0).ToExpression())));
1556
1557 getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1558 new MethodInvocationExpression(
1559 arg1, typeof(SerializationInfo).GetMethod("SetType"),
1560 typeLocal.ToExpression())));
1561
1562 getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1563 new MethodInvocationExpression(arg1, addValueMethod,
1564 new ConstReference("__interceptors").
1565 ToExpression(),
1566 interceptorsField.ToExpression())));
1567
1568 LocalReference interfacesLocal =
1569 getObjectData.CodeBuilder.DeclareLocal(typeof(String[]));
1570
1571 getObjectData.CodeBuilder.AddStatement(
1572 new AssignStatement(interfacesLocal,
1573 new NewArrayExpression(interfaces.Length, typeof(String))));
1574
1575 for(int i = 0; i < interfaces.Length; i++)
1576 {
1577 getObjectData.CodeBuilder.AddStatement(new AssignArrayStatement(
1578 interfacesLocal, i,
1579 new ConstReference(interfaces[i].AssemblyQualifiedName).ToExpression()));
1580 }
1581
1582 getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1583 new MethodInvocationExpression(arg1, addValueMethod,
1584 new ConstReference("__interfaces").
1585 ToExpression(),
1586 interfacesLocal.ToExpression())));
1587
1588 getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1589 new MethodInvocationExpression(arg1, addValueMethod,
1590 new ConstReference("__baseType").
1591 ToExpression(),
1592 new ConstReference (emitter.BaseType.AssemblyQualifiedName).ToExpression())));
1593
1594 getObjectData.CodeBuilder.AddStatement(new ExpressionStatement(
1595 new MethodInvocationExpression(arg1, addValueMethod,
1596 new ConstReference("__proxyGenerationOptions").
1597 ToExpression(),
1598 proxyGenerationOptionsField.ToExpression())));
1599
1600 CustomizeGetObjectData(getObjectData.CodeBuilder, arg1, arg2);
1601
1602 getObjectData.CodeBuilder.AddStatement(new ReturnStatement());
1603 }
1604
1605 protected virtual void CustomizeGetObjectData(
1606 AbstractCodeBuilder codebuilder, ArgumentReference arg1,
1607 ArgumentReference arg2)
1608 {
1609 }
1610
1611
1612 protected bool VerifyIfBaseImplementsGetObjectData(Type baseType)
1613 {
1614 // If base type implements ISerializable, we have to make sure
1615 // the GetObjectData is marked as virtual
1616
1617 if (typeof(ISerializable).IsAssignableFrom(baseType))
1618 {
1619 MethodInfo getObjectDataMethod = baseType.GetMethod("GetObjectData",
1620 new Type[] {typeof(SerializationInfo), typeof(StreamingContext)});
1621
1622 if (getObjectDataMethod == null) //explicit interface implementation
1623 {
1624 return false;
1625 }
1626
1627 if (!getObjectDataMethod.IsVirtual || getObjectDataMethod.IsFinal)
1628 {
1629 String message = String.Format("The type {0} implements ISerializable, but GetObjectData is not marked as virtual",
1630 baseType.FullName);
1631 throw new ArgumentException(message);
1632 }
1633
1634 methodsToSkip.Add(getObjectDataMethod);
1635
1636 serializationConstructor = baseType.GetConstructor(
1637 BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
1638 null,
1639 new Type[] {typeof(SerializationInfo), typeof(StreamingContext)},
1640 null);
1641
1642 if (serializationConstructor == null)
1643 {
1644 String message =
1645 String.Format("The type {0} implements ISerializable, but failed to provide a deserialization constructor",
1646 baseType.FullName);
1647 throw new ArgumentException(message);
1648 }
1649
1650 return true;
1651 }
1652 return false;
1653 }
1654
1655 private bool SpecialCaseAttributThatShouldNotBeReplicated(Attribute attribute)
1656 {
1657 return attribute.GetType() == typeof(ComImportAttribute);
1658 }
1659 }
1660 }
Git import of castle svn