1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.ComIntegration
{
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime;
using System.Runtime.InteropServices;
using System.Threading;
class EmitterCache
{
static EmitterCache Provider = null;
static object initLock = new object();
internal static EmitterCache TypeEmitter
{
get
{
lock (initLock)
{
if (Provider == null)
{
EmitterCache localProvider = new EmitterCache();
Thread.MemoryBarrier();
Provider = localProvider;
}
}
if (Provider == null)
{
throw Fx.AssertAndThrowFatal("Provider should not be null");
}
return Provider;
}
}
ModuleBuilder DynamicModule;
AssemblyBuilder assemblyBuilder;
Dictionary<Type, Type> interfaceToClassMap;
private EmitterCache()
{
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = Guid.NewGuid().ToString();
assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
DynamicModule = assemblyBuilder.DefineDynamicModule(Guid.NewGuid().ToString());
interfaceToClassMap = new Dictionary<Type, Type>();
}
private Type[] GetParameterTypes(MethodInfo mInfo)
{
ParameterInfo[] parameters = mInfo.GetParameters();
Type[] typeArray = new Type[parameters.Length];
int index = 0;
for (; index < parameters.Length; index++)
{
typeArray[index] = parameters[index].ParameterType;
}
return typeArray;
}
[SuppressMessage(FxCop.Category.Usage, "CA2301:EmbeddableTypesInContainersRule", MessageId = "interfaceToClassMap", Justification = "No need to support type equivalence here.")]
internal Type FindOrCreateType(Type interfaceType)
{
if (!interfaceType.IsInterface)
{
throw Fx.AssertAndThrow("Passed in type should be an Interface");
}
Type classType = null;
lock (this)
{
interfaceToClassMap.TryGetValue(interfaceType, out classType);
if (classType == null)
{
TypeBuilder typeBuilder = DynamicModule.DefineType(interfaceType.Name + "MarshalByRefObject", TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Abstract,
typeof(MarshalByRefObject), new Type[] { interfaceType });
Type[] ctorParams = new Type[] { typeof(ClassInterfaceType) };
ConstructorInfo classCtorInfo = typeof(ClassInterfaceAttribute).GetConstructor(ctorParams);
CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(classCtorInfo,
new object[] { ClassInterfaceType.None });
typeBuilder.SetCustomAttribute(attributeBuilder);
typeBuilder.AddInterfaceImplementation(interfaceType);
foreach (MethodInfo mInfo in interfaceType.GetMethods())
{
MethodBuilder methodInClass = null;
methodInClass = typeBuilder.DefineMethod(mInfo.Name,
MethodAttributes.Public | MethodAttributes.Virtual |
MethodAttributes.Abstract | MethodAttributes.Abstract | MethodAttributes.HideBySig | MethodAttributes.NewSlot,
mInfo.ReturnType, GetParameterTypes(mInfo));
}
classType = typeBuilder.CreateType();
interfaceToClassMap[interfaceType] = classType;
}
}
if (classType == null)
{
throw Fx.AssertAndThrow("Class Type should not be null at this point");
}
return classType;
}
}
}
|
