1: public class Manager:Singleton<Manager>
2: {
3: protected Manager()
4: : base()
5: {
6: Configuration = Gestalt.Manager.Instance.GetConfigFile<Configuration>("AspectusConfiguration");
7: if (Configuration.AspectLocation.EndsWith(".dll",StringComparison.CurrentCultureIgnoreCase))
8: {
9: Assembly TempAssembly = Assembly.LoadFile(Configuration.AspectLocation);
10: Gestalt.Manager.Instance.RegisterConfigFile(TempAssembly);
11: DotExtension.Manager.Instance.Setup(TempAssembly);
12: }
13: else if (Utilities.IO.FileManager.DirectoryExists(Configuration.AspectLocation))
14: {
15: List<Assembly> Assemblies = Utilities.Reflection.Reflection.GetAssembliesFromDirectory(Configuration.AspectLocation, true);
16: foreach (Assembly Assembly in Assemblies)
17: {
18: Gestalt.Manager.Instance.RegisterConfigFile(Assembly);
19: DotExtension.Manager.Instance.Setup(Assembly);
20: }
21: }
22: else
23: {
24: Assembly TempAssembly = Assembly.Load(Configuration.AspectLocation);
25: Gestalt.Manager.Instance.RegisterConfigFile(TempAssembly);
26: DotExtension.Manager.Instance.Setup(TempAssembly);
27: }
28: Classes = new Dictionary<Type, Type>();
29: AssemblyName Name = new AssemblyName(Configuration.AssemblyName);
30: AppDomain Domain = Thread.GetDomain();
31: Builder = Domain.DefineDynamicAssembly(Name, AssemblyBuilderAccess.RunAndSave, Configuration.AssemblyDirectory);
32: Module = Builder.DefineDynamicModule(Configuration.AssemblyName, Configuration.AssemblyName + ".dll", true);
33: }
34:
35: public void Save()
36: {
37: Builder.Save(Configuration.AssemblyName + ".dll");
38: }
39:
40: public void Setup(Type Type)
41: {
42: List<Type> Interfaces = new List<Type>();
43: foreach (IAspect Extension in DotExtension.Manager.Instance.Extensions.OfType<IAspect>())
44: {
45: if (Extension.InterfacesUsing != null)
46: {
47: Interfaces.AddRange(Extension.InterfacesUsing);
48: }
49: }
50: Interfaces.Add(typeof(IEvents));
51: TypeBuilder TypeBuilder = Module.DefineType(Configuration.AssemblyName + "." + Type.Name + "Derived", TypeAttributes.Public, Type, Interfaces.ToArray());
52: MethodAttributes GetSetAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual;
53: CreateStartingEvent(TypeBuilder, GetSetAttributes);
54: CreateEndingEvent(TypeBuilder, GetSetAttributes);
55: CreateExceptionEvent(TypeBuilder, GetSetAttributes);
56:
57: foreach (IAspect Extension in DotExtension.Manager.Instance.Extensions.OfType<IAspect>())
58: {
59: Extension.SetupInterfaces(TypeBuilder);
60: }
61:
62: foreach (MethodInfo Method in Type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance))
63: {
64: if (Method.IsVirtual)
65: {
66: CreateMethod(Type, Method, TypeBuilder);
67: }
68: }
69:
70: Classes.Add(Type, TypeBuilder.CreateType());
71: }
72:
73: public T Create<T>()
74: {
75: T ReturnObject = (T)Classes[typeof(T)].Assembly.CreateInstance(Classes[typeof(T)].FullName);
76: foreach (IAspect Extension in DotExtension.Manager.Instance.Extensions.OfType<IAspect>())
77: {
78: Extension.Setup(ReturnObject);
79: }
80: return ReturnObject;
81: }
82:
83: private void CreateMethod(Type Type, MethodInfo Method, TypeBuilder TypeBuilder)
84: {
85: MethodAttributes MethodAttribute = MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Public;
86: if (Method.IsStatic)
87: MethodAttribute |= MethodAttributes.Static;
88: ParameterInfo[] Parameters = Method.GetParameters();
89: Type[] ParameterTypes = new Type[Parameters.Length];
90: int x = 0;
91: foreach (ParameterInfo Parameter in Parameters)
92: {
93: ParameterTypes[x] = Parameter.ParameterType;
94: ++x;
95: }
96: MethodBuilder TempMethodBuilder = TypeBuilder.DefineMethod(Method.Name, MethodAttribute, Method.ReturnType, ParameterTypes);
97: ILGenerator MethodILGenerator = TempMethodBuilder.GetILGenerator();
98: LocalBuilder LocalReturn = null;
99: if (Method.ReturnType != typeof(void))
100: {
101: LocalReturn = MethodILGenerator.DeclareLocal(Method.ReturnType);
102: }
103: LocalBuilder StartingArgs = MethodILGenerator.DeclareLocal(typeof(Starting));
104: LocalBuilder EndingArgs = MethodILGenerator.DeclareLocal(typeof(Ending));
105: LocalBuilder ErrorArgs = MethodILGenerator.DeclareLocal(typeof(Aspectus.EventArgs.Exception));
106: Label MethodTryEndLabel = MethodILGenerator.DefineLabel();
107: MethodILGenerator.BeginExceptionBlock();
108: AddStartingBlock(MethodILGenerator, StartingArgs, Method, LocalReturn);
109: foreach (IAspect Extension in DotExtension.Manager.Instance.Extensions.OfType<IAspect>())
110: {
111: Extension.SetupStartMethod(MethodILGenerator, Method, Type);
112: }
113: if (!Method.IsStatic)
114: {
115: MethodILGenerator.Emit(OpCodes.Ldarg_0);
116: }
117: foreach (ParameterInfo Parameter in Parameters)
118: {
119: MethodILGenerator.Emit(OpCodes.Ldarg, Parameter.Position + (Method.IsStatic ? 0 : 1));
120: }
121: MethodILGenerator.EmitCall(OpCodes.Call, Method, new Type[0]);
122: if (Method.ReturnType != typeof(void))
123: {
124: MethodILGenerator.Emit(OpCodes.Stloc, LocalReturn.LocalIndex);
125: }
126: MethodILGenerator.Emit(OpCodes.Br_S, MethodTryEndLabel);
127: AddExceptionBlock(MethodILGenerator, Method, Type, ErrorArgs);
128:
129: MethodILGenerator.MarkLabel(MethodTryEndLabel);
130:
131: foreach (IAspect Extension in DotExtension.Manager.Instance.Extensions.OfType<IAspect>())
132: {
133: Extension.SetupEndMethod(MethodILGenerator, Method, Type, LocalReturn);
134: }
135:
136: AddEndingBlock(MethodILGenerator, EndingArgs, Method, LocalReturn);
137: if (Method.ReturnType != typeof(void))
138: {
139: MethodILGenerator.Emit(OpCodes.Ldloc, LocalReturn.LocalIndex);
140: }
141: MethodILGenerator.Emit(OpCodes.Ret);
142: TypeBuilder.DefineMethodOverride(TempMethodBuilder, Method);
143: }
144:
145: private void AddEndingBlock(ILGenerator Generator, LocalBuilder EndingArgs, MethodInfo Method,LocalBuilder LocalReturn)
146: {
147: Generator.Emit(OpCodes.Newobj, typeof(Ending).GetConstructor(new Type[0]));
148: Generator.Emit(OpCodes.Stloc, EndingArgs.LocalIndex);
149: Generator.Emit(OpCodes.Ldloc, EndingArgs.LocalIndex);
150: Generator.Emit(OpCodes.Ldstr, Method.Name);
151: Generator.EmitCall(OpCodes.Callvirt, typeof(Ending).GetProperty("MethodName").GetSetMethod(), null);
152: if (LocalReturn != null)
153: {
154: Generator.Emit(OpCodes.Ldloc, EndingArgs.LocalIndex);
155: Generator.Emit(OpCodes.Ldloc, LocalReturn.LocalIndex);
156: Generator.Emit(OpCodes.Box, LocalReturn.LocalType);
157: Generator.EmitCall(OpCodes.Callvirt, typeof(Ending).GetProperty("ReturnValue").GetSetMethod(), null);
158: }
159: ParameterInfo[] Parameters = Method.GetParameters();
160: foreach (ParameterInfo Parameter in Parameters)
161: {
162: Generator.Emit(OpCodes.Ldloc, EndingArgs.LocalIndex);
163: Generator.EmitCall(OpCodes.Callvirt, typeof(Ending).GetProperty("Parameters").GetGetMethod(), null);
164: Generator.Emit(OpCodes.Ldarg, Parameter.Position + (Method.IsStatic ? 0 : 1));
165: if (!Parameter.ParameterType.IsByRef)
166: {
167: Generator.Emit(OpCodes.Box, Parameter.ParameterType);
168: }
169: else
170: {
171: Generator.Emit(OpCodes.Box, typeof(int));
172: }
173: Generator.EmitCall(OpCodes.Callvirt, typeof(List<object>).GetMethod("Add"), null);
174: }
175: Generator.Emit(OpCodes.Nop);
176: Generator.Emit(OpCodes.Ldarg_0);
177: Generator.Emit(OpCodes.Castclass, typeof(IEvents));
178: Generator.EmitCall(OpCodes.Callvirt, typeof(IEvents).GetProperty("Aspectus_Ending").GetGetMethod(), null);
179: Generator.Emit(OpCodes.Ldarg_0);
180: Generator.Emit(OpCodes.Ldloc, EndingArgs.LocalIndex);
181: Type EventHelperType = typeof(Utilities.Events.EventHelper);
182: MethodInfo[] Methods = EventHelperType.GetMethods();
183: MethodInfo TempMethod = null;
184: foreach (MethodInfo TempMethodInfo in Methods)
185: {
186: if (TempMethodInfo.GetParameters().Length == 3)
187: {
188: TempMethod = TempMethodInfo;
189: break;
190: }
191: }
192: TempMethod = TempMethod.MakeGenericMethod(new Type[] { typeof(Ending) });
193: Generator.EmitCall(OpCodes.Call, TempMethod, null);
194: if (LocalReturn != null)
195: {
196: Label Equal = Generator.DefineLabel();
197: Generator.Emit(OpCodes.Ldloc, EndingArgs.LocalIndex);
198: Generator.EmitCall(OpCodes.Callvirt, typeof(Ending).GetProperty("ReturnValue").GetGetMethod(), null);
199: Generator.Emit(OpCodes.Ldnull);
200: Generator.Emit(OpCodes.Ceq);
201: Generator.Emit(OpCodes.Brtrue_S, Equal);
202: Generator.Emit(OpCodes.Ldloc, EndingArgs.LocalIndex);
203: Generator.EmitCall(OpCodes.Callvirt, typeof(Ending).GetProperty("ReturnValue").GetGetMethod(), null);
204: Generator.Emit(OpCodes.Unbox_Any, LocalReturn.LocalType);
205: Generator.Emit(OpCodes.Stloc, LocalReturn.LocalIndex);
206: Generator.MarkLabel(Equal);
207: }
208: }
209:
210: private void AddExceptionBlock(ILGenerator Generator, MethodInfo MethodInfo, Type Type, LocalBuilder ErrorArgs)
211: {
212: Generator.BeginCatchBlock(typeof(System.Exception));
213:
214: Generator.Emit(OpCodes.Stloc_0);
215: Generator.Emit(OpCodes.Newobj, typeof(Aspectus.EventArgs.Exception).GetConstructor(new Type[0]));
216: Generator.Emit(OpCodes.Stloc, ErrorArgs.LocalIndex);
217: Generator.Emit(OpCodes.Ldloc, ErrorArgs.LocalIndex);
218: Generator.Emit(OpCodes.Ldloc_0);
219: Generator.EmitCall(OpCodes.Callvirt, typeof(Aspectus.EventArgs.Exception).GetProperty("InternalException").GetSetMethod(), null);
220: Generator.Emit(OpCodes.Nop);
221: Generator.Emit(OpCodes.Ldarg_0);
222: Generator.Emit(OpCodes.Castclass, typeof(IEvents));
223: Generator.EmitCall(OpCodes.Callvirt, typeof(IEvents).GetProperty("Aspectus_Exception").GetGetMethod(), null);
224: Generator.Emit(OpCodes.Ldarg_0);
225: Generator.Emit(OpCodes.Ldloc, ErrorArgs.LocalIndex);
226: Type EventHelperType = typeof(Utilities.Events.EventHelper);
227: MethodInfo[] Methods = EventHelperType.GetMethods();
228: MethodInfo TempMethod = null;
229: foreach (MethodInfo Method in Methods)
230: {
231: if (Method.GetParameters().Length == 3)
232: {
233: TempMethod = Method;
234: break;
235: }
236: }
237: TempMethod = TempMethod.MakeGenericMethod(new Type[] { typeof(Aspectus.EventArgs.Exception) });
238: Generator.EmitCall(OpCodes.Call, TempMethod, null);
239: foreach (IAspect Extension in DotExtension.Manager.Instance.Extensions.OfType<IAspect>())
240: {
241: Extension.SetupExceptionMethod(Generator, MethodInfo, Type);
242: }
243: Generator.Emit(OpCodes.Rethrow);
244: Generator.EndExceptionBlock();
245: }
246:
247: private void AddStartingBlock(ILGenerator Generator, LocalBuilder StartingArgs, MethodInfo Method,LocalBuilder LocalReturn)
248: {
249: Generator.Emit(OpCodes.Newobj, typeof(Starting).GetConstructor(new Type[0]));
250: Generator.Emit(OpCodes.Stloc, StartingArgs.LocalIndex);
251: Generator.Emit(OpCodes.Ldloc, StartingArgs.LocalIndex);
252: Generator.Emit(OpCodes.Ldstr, Method.Name);
253: Generator.EmitCall(OpCodes.Callvirt, typeof(Starting).GetProperty("MethodName").GetSetMethod(), null);
254: ParameterInfo[] Parameters = Method.GetParameters();
255: foreach (ParameterInfo Parameter in Parameters)
256: {
257: Generator.Emit(OpCodes.Ldloc, StartingArgs.LocalIndex);
258: Generator.EmitCall(OpCodes.Callvirt, typeof(Starting).GetProperty("Parameters").GetGetMethod(), null);
259: Generator.Emit(OpCodes.Ldarg, Parameter.Position + (Method.IsStatic ? 0 : 1));
260: if (!Parameter.ParameterType.IsByRef)
261: {
262: Generator.Emit(OpCodes.Box, Parameter.ParameterType);
263: }
264: else
265: {
266: Generator.Emit(OpCodes.Box, typeof(int));
267: }
268: Generator.EmitCall(OpCodes.Callvirt, typeof(List<object>).GetMethod("Add"), null);
269: }
270: Generator.Emit(OpCodes.Ldarg_0);
271: Generator.Emit(OpCodes.Castclass, typeof(IEvents));
272: Generator.EmitCall(OpCodes.Callvirt, typeof(IEvents).GetProperty("Aspectus_Starting").GetGetMethod(), null);
273: Generator.Emit(OpCodes.Ldarg_0);
274: Generator.Emit(OpCodes.Ldloc, StartingArgs.LocalIndex);
275: Type EventHelperType = typeof(Utilities.Events.EventHelper);
276: MethodInfo[] Methods = EventHelperType.GetMethods();
277: MethodInfo TempMethod = null;
278: foreach (MethodInfo TempMethodInfo in Methods)
279: {
280: if (TempMethodInfo.GetParameters().Length == 3)
281: {
282: TempMethod = TempMethodInfo;
283: break;
284: }
285: }
286: TempMethod = TempMethod.MakeGenericMethod(new Type[] { typeof(Starting) });
287: Generator.EmitCall(OpCodes.Call, TempMethod, null);
288: if (LocalReturn != null)
289: {
290: Label Equal = Generator.DefineLabel();
291: Generator.Emit(OpCodes.Ldloc, StartingArgs.LocalIndex);
292: Generator.EmitCall(OpCodes.Callvirt, typeof(Starting).GetProperty("ReturnValue").GetGetMethod(), null);
293: Generator.Emit(OpCodes.Ldnull);
294: Generator.Emit(OpCodes.Ceq);
295: Generator.Emit(OpCodes.Brtrue_S, Equal);
296: Generator.Emit(OpCodes.Ldloc, StartingArgs.LocalIndex);
297: Generator.EmitCall(OpCodes.Callvirt, typeof(Starting).GetProperty("ReturnValue").GetGetMethod(), null);
298: Generator.Emit(OpCodes.Unbox_Any, LocalReturn.LocalType);
299: Generator.Emit(OpCodes.Stloc, LocalReturn.LocalIndex);
300: Generator.Emit(OpCodes.Ldloc, LocalReturn.LocalIndex);
301: Generator.Emit(OpCodes.Ret);
302: Generator.MarkLabel(Equal);
303: }
304: }
305:
306: private void CreateStartingEvent(TypeBuilder TypeBuilder, MethodAttributes GetSetAttributes)
307: {
308: FieldBuilder FieldBuilder = TypeBuilder.DefineField("_Aspectus_Starting", typeof(EventHandler<Starting>), FieldAttributes.Private);
309: PropertyBuilder PropertyBuilder = TypeBuilder.DefineProperty("Aspectus_Starting", PropertyAttributes.SpecialName,
310: typeof(EventHandler<Starting>), null);
311: MethodBuilder ValuePropertyGet = TypeBuilder.DefineMethod("get_Aspectus_Starting", GetSetAttributes,
312: typeof(EventHandler<Starting>), Type.EmptyTypes);
313: ILGenerator GetGenerator = ValuePropertyGet.GetILGenerator();
314: GetGenerator.Emit(OpCodes.Ldarg_0);
315: GetGenerator.Emit(OpCodes.Ldfld, FieldBuilder);
316: GetGenerator.Emit(OpCodes.Ret);
317: PropertyBuilder.SetGetMethod(ValuePropertyGet);
318:
319: MethodBuilder ValuePropertySet = TypeBuilder.DefineMethod("set_Aspectus_Starting", GetSetAttributes, null,
320: new Type[] { typeof(EventHandler<Starting>) });
321: ILGenerator SetGenerator = ValuePropertySet.GetILGenerator();
322: SetGenerator.Emit(OpCodes.Ldarg_0);
323: SetGenerator.Emit(OpCodes.Ldarg_1);
324: SetGenerator.Emit(OpCodes.Stfld, FieldBuilder);
325: SetGenerator.Emit(OpCodes.Ret);
326: PropertyBuilder.SetSetMethod(ValuePropertySet);
327: }
328:
329: private void CreateEndingEvent(TypeBuilder TypeBuilder, MethodAttributes GetSetAttributes)
330: {
331: FieldBuilder FieldBuilder = TypeBuilder.DefineField("_Aspectus_Ending", typeof(EventHandler<Ending>), FieldAttributes.Private);
332: PropertyBuilder PropertyBuilder = TypeBuilder.DefineProperty("Aspectus_Ending", PropertyAttributes.SpecialName,
333: typeof(EventHandler<Ending>), null);
334: MethodBuilder ValuePropertyGet = TypeBuilder.DefineMethod("get_Aspectus_Ending", GetSetAttributes,
335: typeof(EventHandler<Ending>), Type.EmptyTypes);
336: ILGenerator GetGenerator = ValuePropertyGet.GetILGenerator();
337: GetGenerator.Emit(OpCodes.Ldarg_0);
338: GetGenerator.Emit(OpCodes.Ldfld, FieldBuilder);
339: GetGenerator.Emit(OpCodes.Ret);
340: PropertyBuilder.SetGetMethod(ValuePropertyGet);
341:
342: MethodBuilder ValuePropertySet = TypeBuilder.DefineMethod("set_Aspectus_Ending", GetSetAttributes, null,
343: new Type[] { typeof(EventHandler<Ending>) });
344: ILGenerator SetGenerator = ValuePropertySet.GetILGenerator();
345: SetGenerator.Emit(OpCodes.Ldarg_0);
346: SetGenerator.Emit(OpCodes.Ldarg_1);
347: SetGenerator.Emit(OpCodes.Stfld, FieldBuilder);
348: SetGenerator.Emit(OpCodes.Ret);
349: PropertyBuilder.SetSetMethod(ValuePropertySet);
350: }
351:
352: private void CreateExceptionEvent(TypeBuilder TypeBuilder, MethodAttributes GetSetAttributes)
353: {
354: FieldBuilder FieldBuilder = TypeBuilder.DefineField("_Aspectus_Exception", typeof(EventHandler<Aspectus.EventArgs.Exception>), FieldAttributes.Private);
355: PropertyBuilder PropertyBuilder = TypeBuilder.DefineProperty("Aspectus_Exception", PropertyAttributes.SpecialName,
356: typeof(EventHandler<Aspectus.EventArgs.Exception>), null);
357: MethodBuilder ValuePropertyGet = TypeBuilder.DefineMethod("get_Aspectus_Exception", GetSetAttributes,
358: typeof(EventHandler<Aspectus.EventArgs.Exception>), Type.EmptyTypes);
359: ILGenerator GetGenerator = ValuePropertyGet.GetILGenerator();
360: GetGenerator.Emit(OpCodes.Ldarg_0);
361: GetGenerator.Emit(OpCodes.Ldfld, FieldBuilder);
362: GetGenerator.Emit(OpCodes.Ret);
363: PropertyBuilder.SetGetMethod(ValuePropertyGet);
364:
365: MethodBuilder ValuePropertySet = TypeBuilder.DefineMethod("set_Aspectus_Exception", GetSetAttributes, null,
366: new Type[] { typeof(EventHandler<Aspectus.EventArgs.Exception>) });
367: ILGenerator SetGenerator = ValuePropertySet.GetILGenerator();
368: SetGenerator.Emit(OpCodes.Ldarg_0);
369: SetGenerator.Emit(OpCodes.Ldarg_1);
370: SetGenerator.Emit(OpCodes.Stfld, FieldBuilder);
371: SetGenerator.Emit(OpCodes.Ret);
372: PropertyBuilder.SetSetMethod(ValuePropertySet);
373: }
374:
375: protected AssemblyBuilder Builder { get; set; }
376: protected ModuleBuilder Module { get; set; }
377: protected Dictionary<Type, Type> Classes { get; set; }
378: protected Configuration Configuration { get; set; }
379: }