From: jpbruyere Date: Sun, 1 Jan 2017 09:21:36 +0000 (+0100) Subject: caching of recurent reflexion elements X-Git-Tag: v0.5.1~63^2~2 X-Git-Url: https://git.osiis.dedyn.io/?a=commitdiff_plain;h=e0a9da2413da9ba0a860baf064a39941178ee34a;p=jp%2Fcrow.git caching of recurent reflexion elements --- diff --git a/src/Colors.cs b/src/Colors.cs index b76de623..65a7f037 100644 --- a/src/Colors.cs +++ b/src/Colors.cs @@ -15,6 +15,8 @@ namespace Crow /// public struct Color { + internal static Type TColor = typeof(Color); + #region CTOR public Color(double _R, double _G, double _B, double _A) { @@ -1046,7 +1048,7 @@ namespace Crow } public override bool Equals (object obj) { - return (obj == null || obj.GetType() != typeof(Color)) ? + return (obj == null || obj.GetType() != TColor) ? false : this == (Color)obj; } diff --git a/src/CompilerServices/CompilerServices.cs b/src/CompilerServices/CompilerServices.cs index f837e484..0bd4b5c4 100644 --- a/src/CompilerServices/CompilerServices.cs +++ b/src/CompilerServices/CompilerServices.cs @@ -13,52 +13,83 @@ namespace Crow { public static class CompilerServices { - static FieldInfo miSetCurIface = typeof(GraphicObject).GetField ("currentInterface", - BindingFlags.NonPublic | BindingFlags.Instance); - internal static MethodInfo stringEquals = typeof (string).GetMethod - ("Equals", new Type [3] { typeof (string), typeof (string), typeof (StringComparison) }); - public static MethodInfo miFindByName = typeof (GraphicObject).GetMethod ("FindByName"); - - public static MethodInfo miIFaceLoad = typeof(Interface).GetMethod ("Load", BindingFlags.Instance | BindingFlags.Public); - public static MethodInfo miGetITemp = typeof(Interface).GetMethod ("GetItemTemplate"); - public static MethodInfo miAddITemp = typeof(Dictionary). - GetMethod ("set_Item", new Type[] { typeof(string), typeof(ItemTemplate) }); - public static MethodInfo miGetITempFromDic = typeof(Dictionary). - GetMethod ("get_Item", new Type[] { typeof(string) }); - public static FieldInfo fldItemTemplates = typeof(TemplatedGroup).GetField("ItemTemplates"); - public static MethodInfo miCreateExpDel = typeof(ItemTemplate).GetMethod ("CreateExpandDelegate"); - public static MethodInfo miLoadDefaultVals = typeof (GraphicObject).GetMethod ("loadDefaultValues"); - public static PropertyInfo piStyle = typeof (GraphicObject).GetProperty ("Style"); - public static MethodInfo miGetTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle"); + internal static Type TObject = typeof(object); + internal static MethodInfo stringEquals = typeof (string).GetMethod("Equals", new Type [3] { typeof (string), typeof (string), typeof (StringComparison) }); + internal static MethodInfo miObjToString = typeof(object).GetMethod("ToString"); + internal static MethodInfo miGetType = typeof(object).GetMethod("GetType"); + internal static MethodInfo miParseEnum = typeof(Enum).GetMethod("Parse", BindingFlags.Static | BindingFlags.Public, + Type.DefaultBinder, new Type [] {typeof (Type), typeof (string), typeof (bool)}, null); + + internal static MethodInfo miGetTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle"); + internal static MethodInfo miGetEvent = typeof(Type).GetMethod("GetEvent", new Type[] {typeof(string)}); + + internal static MethodInfo miMIInvoke = typeof(MethodInfo).GetMethod ("Invoke", new Type[] { + typeof(object), + typeof(object[]) + }); + + internal static MethodInfo miCreateBoundDel = typeof(Delegate).GetMethod ("CreateDelegate", new Type[] { typeof(Type), typeof(object), typeof(MethodInfo) });//create bound delegate + internal static MethodInfo miGetColCount = typeof(System.Collections.ICollection).GetProperty("Count").GetGetMethod(); + internal static MethodInfo miGetDelegateListItem = typeof(List).GetMethod("get_Item", new Type[] { typeof(Int32) }); + + internal static MethodInfo miCompileDynEventHandler = typeof(CompilerServices).GetMethod ("compileDynEventHandler", BindingFlags.Static | BindingFlags.Public); + internal static MethodInfo miRemEvtHdlByName = typeof(CompilerServices).GetMethod("RemoveEventHandlerByName", BindingFlags.Static | BindingFlags.Public); + internal static MethodInfo miRemEvtHdlByTarget = typeof(CompilerServices).GetMethod("RemoveEventHandlerByTarget", BindingFlags.Static | BindingFlags.Public); + internal static MethodInfo miGetMethInfoWithRefx = typeof(CompilerServices).GetMethod ("getMethodInfoWithReflexion", BindingFlags.Static | BindingFlags.Public); + internal static MethodInfo miGetMembIinfoWithRefx = typeof(CompilerServices).GetMethod("getMemberInfoWithReflexion", BindingFlags.Static | BindingFlags.Public); + internal static MethodInfo miSetValWithRefx = typeof(CompilerServices).GetMethod("setValueWithReflexion", BindingFlags.Static | BindingFlags.Public); + internal static MethodInfo miGetValWithRefx = typeof(CompilerServices).GetMethod("getValueWithReflexion", BindingFlags.Static | BindingFlags.Public); + internal static MethodInfo miCreateDel = typeof(CompilerServices).GetMethod ("createDel", BindingFlags.Static | BindingFlags.NonPublic); + internal static MethodInfo miGetImplOp = typeof(CompilerServices).GetMethod ("getImplicitOp", BindingFlags.Static | BindingFlags.Public); + + internal static FieldInfo fiCachedDel = typeof(Instantiator).GetField("cachedDelegates", BindingFlags.Instance | BindingFlags.NonPublic); + internal static FieldInfo fiTemplateBinding = typeof(Instantiator).GetField("templateBinding", BindingFlags.Instance | BindingFlags.NonPublic); + internal static MethodInfo miDSChangeEmitHelper = typeof(Instantiator).GetMethod("dataSourceChangedEmitHelper", BindingFlags.Instance | BindingFlags.NonPublic); + internal static MethodInfo miDSReverseBinding = typeof(Instantiator).GetMethod("dataSourceReverseBinding", BindingFlags.Static | BindingFlags.NonPublic); + + internal static FieldInfo miSetCurIface = typeof(GraphicObject).GetField ("currentInterface", BindingFlags.NonPublic | BindingFlags.Instance); + internal static MethodInfo miFindByName = typeof (GraphicObject).GetMethod ("FindByName"); + internal static MethodInfo miGetGObjItem = typeof(List).GetMethod("get_Item", new Type[] { typeof(Int32) }); + internal static MethodInfo miLoadDefaultVals = typeof (GraphicObject).GetMethod ("loadDefaultValues"); + internal static PropertyInfo piStyle = typeof (GraphicObject).GetProperty ("Style"); + internal static MethodInfo miGetLogicalParent = typeof(GraphicObject).GetProperty("LogicalParent").GetGetMethod(); + internal static MethodInfo miGetDataSource = typeof(GraphicObject).GetProperty("DataSource").GetGetMethod (); + internal static EventInfo eiLogicalParentChanged = typeof(GraphicObject).GetEvent("LogicalParentChanged"); + + internal static MethodInfo miIFaceLoad = typeof(Interface).GetMethod ("Load", BindingFlags.Instance | BindingFlags.Public); + internal static MethodInfo miGetITemp = typeof(Interface).GetMethod ("GetItemTemplate"); + + internal static MethodInfo miAddITemp = typeof(Dictionary).GetMethod ("set_Item", new Type[] { typeof(string), typeof(ItemTemplate) }); + internal static MethodInfo miGetITempFromDic = typeof(Dictionary).GetMethod ("get_Item", new Type[] { typeof(string) }); + internal static FieldInfo fldItemTemplates = typeof(TemplatedGroup).GetField("ItemTemplates"); + internal static MethodInfo miCreateExpDel = typeof(ItemTemplate).GetMethod ("CreateExpandDelegate"); + #region tree handling methods + internal static FieldInfo fiChild = typeof(PrivateContainer).GetField ("child", BindingFlags.Instance | BindingFlags.NonPublic); internal static MethodInfo miSetChild = typeof (Container).GetMethod ("SetChild"); internal static MethodInfo miAddChild = typeof (Group).GetMethod ("AddChild"); + internal static FieldInfo fiChildren = typeof(Group).GetField ("children", BindingFlags.Instance | BindingFlags.NonPublic); internal static MethodInfo miLoadTmp = typeof (TemplatedControl).GetMethod ("loadTemplate", BindingFlags.Instance | BindingFlags.NonPublic); - internal static MethodInfo miSetContent = typeof (TemplatedContainer).GetProperty ("Content").GetSetMethod (); + internal static PropertyInfo piContent = typeof(TemplatedContainer).GetProperty ("Content"); internal static MethodInfo miAddItem = typeof (TemplatedGroup).GetMethod ("AddItem", BindingFlags.Instance | BindingFlags.Public); + internal static MethodInfo miGetItems = typeof(TemplatedGroup).GetProperty ("Items").GetGetMethod (); #endregion - #region ValueChange Reflexion member info + #region ValueChange & DSChange Reflexion member info internal static EventInfo eiValueChange = typeof (IValueChange).GetEvent ("ValueChanged"); internal static MethodInfo miInvokeValueChange = eiValueChange.EventHandlerType.GetMethod ("Invoke"); internal static Type [] argsBoundValueChange = { typeof (object), typeof (object), miInvokeValueChange.GetParameters () [1].ParameterType }; internal static Type [] argsValueChange = { typeof (object), miInvokeValueChange.GetParameters () [1].ParameterType }; - internal static FieldInfo fiNewValue = typeof (ValueChangeEventArgs).GetField ("NewValue"); - internal static FieldInfo fiMbName = typeof (ValueChangeEventArgs).GetField ("MemberName"); + internal static FieldInfo fiVCNewValue = typeof (ValueChangeEventArgs).GetField ("NewValue"); + internal static FieldInfo fiVCMbName = typeof (ValueChangeEventArgs).GetField ("MemberName"); internal static MethodInfo miValueChangeAdd = eiValueChange.GetAddMethod (); internal static EventInfo eiDSChange = typeof (GraphicObject).GetEvent ("DataSourceChanged"); internal static MethodInfo miInvokeDSChange = eiDSChange.EventHandlerType.GetMethod ("Invoke"); internal static Type [] argsBoundDSChange = {typeof (object), typeof (object), miInvokeDSChange.GetParameters () [1].ParameterType }; internal static FieldInfo fiDSCNewDS = typeof (DataSourceChangeEventArgs).GetField ("NewDataSource"); - - internal static MethodInfo miCreateBoundDelegate = typeof(DynamicMethod). - GetMethod("CreateDelegate", new Type[] { typeof(Type), typeof(object)}); - internal static MethodInfo miObjToString = typeof(object).GetMethod("ToString"); - + internal static FieldInfo fiDSCOldDS = typeof (DataSourceChangeEventArgs).GetField ("OldDataSource"); internal static Type ehTypeDSChange = eiDSChange.EventHandlerType; - internal static FieldInfo fi_ehTypeDSChange = typeof(CompilerServices).GetField("ehTypeDSChange", BindingFlags.Static | BindingFlags.NonPublic); - #endregion /// @@ -148,24 +179,16 @@ namespace Crow if (pi.PropertyType == typeof(string)) il.Emit (OpCodes.Ldstr, Convert.ToString (val)); else if (pi.PropertyType.IsEnum) { - MethodInfo miParse = typeof(Enum).GetMethod - ("Parse", BindingFlags.Static | BindingFlags.Public, - Type.DefaultBinder, new Type [] {typeof (Type), typeof (string), typeof (bool)}, null); - - if (miParse == null) - throw new Exception ("Enum Parse method not found"); - //load type of enum il.Emit(OpCodes.Ldtoken, pi.PropertyType); - il.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle", new - Type[1]{typeof(RuntimeTypeHandle)})); + il.Emit(OpCodes.Call, CompilerServices.miGetTypeFromHandle); //load enum value name il.Emit (OpCodes.Ldstr, Convert.ToString (val));//TODO:is this convert required? //load false il.Emit (OpCodes.Ldc_I4_0); - il.Emit (OpCodes.Callvirt, miParse); + il.Emit (OpCodes.Callvirt, CompilerServices.miParseEnum); - if (miParse.ReturnType != pi.PropertyType) + if (CompilerServices.miParseEnum.ReturnType != pi.PropertyType) il.Emit (OpCodes.Unbox_Any, pi.PropertyType); } else { MethodInfo miParse = pi.PropertyType.GetMethod @@ -184,371 +207,6 @@ namespace Crow il.Emit (OpCodes.Callvirt, pi.GetSetMethod ()); } - public static void ResolveBindings (List Bindings) - { - if (Bindings == null) - return; - if (Bindings.Count == 0) - return; - //#if DEBUG_BINDING - // Debug.WriteLine ("Resolve Bindings => " + this.ToString ()); - //#endif - //grouped bindings by Instance of Source - Dictionary> resolved = new Dictionary> (); - - foreach (Binding b in Bindings) { - if (b.Resolved) - continue; - if (b.Source.Member.MemberType == MemberTypes.Event) { - if (b.Expression.StartsWith ("{")) { - CompilerServices.CompileEventSource (b); - continue; - } - if (!b.TryFindTarget ()) - continue; - //register handler for event - if (b.Target.Method == null) { - //Debug.WriteLine ("\tError: Handler Method not found: " + b.ToString ()); - continue; - } - try { - MethodInfo addHandler = b.Source.Event.GetAddMethod (); - Delegate del = Delegate.CreateDelegate (b.Source.Event.EventHandlerType, b.Target.Instance, b.Target.Method); - addHandler.Invoke (b.Source.Instance, new object [] { del }); - -#if DEBUG_BINDING - Debug.WriteLine ("\tHandler binded => " + b.ToString()); -#endif - b.Resolved = true; - } catch (Exception ex) { - //Debug.WriteLine ("\tERROR: " + ex.ToString ()); - } - continue; - } - - if (!b.TryFindTarget ()) - continue; - - //group Bindings by target instanceq - List bindings = null; - if (!resolved.TryGetValue (b.Target.Instance, out bindings)) { - bindings = new List (); - resolved [b.Target.Instance] = bindings; - } - bindings.Add (b); - b.Resolved = true; - } - - Type target_Type = Bindings [0].Source.Instance.GetType (); - - //group;only one dynMethods by target (valuechanged event source) - //changed value name tested in switch - //IEnumerable groupedByTarget = resolved.GroupBy (g => g.Target.Instance, g => g, (k, g) => g.ToArray ()); - foreach (List grouped in resolved.Values) { - int i = 0; - Type source_Type = grouped [0].Target.Instance.GetType (); - - DynamicMethod dm = null; - ILGenerator il = null; - - System.Reflection.Emit.Label [] jumpTable = null; - System.Reflection.Emit.Label endMethod = new System.Reflection.Emit.Label (); - - #region Retrieve EventHandler parameter type - //EventInfo ei = targetType.GetEvent ("ValueChanged"); - //no dynamic update if ValueChanged interface is not implemented - if (source_Type.GetInterfaces ().Contains (typeof (IValueChange))) { - dm = new DynamicMethod (grouped [0].CreateNewDynMethodId (), - MethodAttributes.Family | MethodAttributes.FamANDAssem | MethodAttributes.NewSlot, - CallingConventions.Standard, - typeof (void), - argsBoundValueChange, - target_Type, true); - - il = dm.GetILGenerator (256); - - endMethod = il.DefineLabel (); - jumpTable = new System.Reflection.Emit.Label [grouped.Count]; - for (i = 0; i < grouped.Count; i++) - jumpTable [i] = il.DefineLabel (); - il.DeclareLocal (typeof (string)); - il.DeclareLocal (typeof (object)); - - il.Emit (OpCodes.Nop); - il.Emit (OpCodes.Ldarg_0); - //il.Emit(OpCodes.Isinst, sourceType); - //push new value onto stack - il.Emit (OpCodes.Ldarg_2); - il.Emit (OpCodes.Ldfld, fiNewValue); - il.Emit (OpCodes.Stloc_1); - //push name - il.Emit (OpCodes.Ldarg_2); - il.Emit (OpCodes.Ldfld, fiMbName); - il.Emit (OpCodes.Stloc_0); - il.Emit (OpCodes.Ldloc_0); - il.Emit (OpCodes.Brfalse, endMethod); - } - #endregion - - i = 0; - foreach (Binding b in grouped) { - #region initialize target with actual value - object targetValue = null; - if (b.Target.Member != null) { - if (b.Target.Member.MemberType == MemberTypes.Property) - targetValue = b.Target.Property.GetGetMethod ().Invoke (b.Target.Instance, null); - else if (b.Target.Member.MemberType == MemberTypes.Field) - targetValue = b.Target.Field.GetValue (b.Target.Instance); - else if (b.Target.Member.MemberType == MemberTypes.Method) { - MethodInfo mthSrc = b.Target.Method; - if (mthSrc.IsDefined (typeof (ExtensionAttribute), false)) - targetValue = mthSrc.Invoke (null, new object [] { b.Target.Instance }); - else - targetValue = mthSrc.Invoke (b.Target.Instance, null); - } else - throw new Exception ("unandled source member type for binding"); - } else if (string.IsNullOrEmpty (b.Expression)) - targetValue = grouped [0].Target.Instance;//empty binding exp=> bound to target object by default - //TODO: handle other dest type conversions - if (b.Source.Property.PropertyType == typeof (string)) { - if (targetValue == null) { - //set default value - - } else - targetValue = targetValue.ToString (); - } - try { - if (targetValue != null) - b.Source.Property.GetSetMethod ().Invoke - (b.Source.Instance, new object [] { b.Source.Property.PropertyType.Cast (targetValue) }); - else - b.Source.Property.GetSetMethod ().Invoke - (b.Source.Instance, new object [] { targetValue }); - } catch (Exception ex) { - Debug.WriteLine (ex.ToString ()); - } - #endregion - - //if no dyn update, skip jump table - if (il == null) - continue; - - il.Emit (OpCodes.Ldloc_0); - if (b.Target.Member != null) - il.Emit (OpCodes.Ldstr, b.Target.Member.Name); - else - il.Emit (OpCodes.Ldstr, b.Expression.Split ('/').LastOrDefault ().Split('.').LastOrDefault()); - il.Emit (OpCodes.Ldc_I4_4);//StringComparison.Ordinal - il.Emit (OpCodes.Callvirt, stringEquals); - il.Emit (OpCodes.Brtrue, jumpTable [i]); - i++; - } - - if (il == null) - continue; - - il.Emit (OpCodes.Br, endMethod); - - i = 0; - foreach (Binding b in grouped) { - - il.MarkLabel (jumpTable [i]); - - - //load 2 times to check first for null - il.Emit (OpCodes.Ldloc_1); - il.Emit (OpCodes.Ldloc_1); - - System.Reflection.Emit.Label labSetValue = il.DefineLabel (); - il.Emit (OpCodes.Brtrue, labSetValue); - //if null - il.Emit (OpCodes.Unbox_Any, b.Source.Property.PropertyType); - il.Emit (OpCodes.Callvirt, b.Source.Property.GetSetMethod ()); - il.Emit (OpCodes.Br, endMethod); - - il.MarkLabel (labSetValue); - //new value not null - - //by default, source value type is deducted from target member type to allow - //memberless binding, if targetMember exists, it will be used to determine target - //value type for conversion - Type sourceValueType = b.Source.Property.PropertyType; - if (b.Target.Member != null) { - if (b.Target.Member.MemberType == MemberTypes.Property) - sourceValueType = b.Target.Property.PropertyType; - else if (b.Target.Member.MemberType == MemberTypes.Field) - sourceValueType = b.Target.Field.FieldType; - else - throw new Exception ("unhandle target member type in binding"); - } - - - - if (b.Source.Property.PropertyType == typeof (string)) { - MemberReference tostring = new MemberReference (b.Source.Instance); - if (!tostring.TryFindMember ("ToString")) - throw new Exception ("ToString method not found"); - il.Emit (OpCodes.Callvirt, tostring.Method); - } else if (!sourceValueType.IsValueType) - il.Emit (OpCodes.Castclass, sourceValueType); - else if (b.Source.Property.PropertyType != sourceValueType && b.Source.Property.PropertyType != typeof(object)) { - il.Emit (OpCodes.Callvirt, CompilerServices.GetConvertMethod (b.Source.Property.PropertyType)); - } else - il.Emit (OpCodes.Unbox_Any, b.Source.Property.PropertyType); - - il.Emit (OpCodes.Callvirt, b.Source.Property.GetSetMethod ()); - - //il.BeginCatchBlock (typeof (Exception)); - //il.Emit (OpCodes.Pop); - //il.EndExceptionBlock (); - - il.Emit (OpCodes.Br, endMethod); - i++; - - } - il.MarkLabel (endMethod); - il.Emit (OpCodes.Pop); - il.Emit (OpCodes.Ret); - - try { - Delegate del = dm.CreateDelegate (eiValueChange.EventHandlerType, Bindings [0].Source.Instance); - miValueChangeAdd.Invoke (grouped [0].Target.Instance, new object [] { del }); - - } catch (Exception ex) { - Debug.WriteLine ("Binding Delegate error for {0}: \n{1}", Bindings [0].Source.Instance, ex.ToString ()); - } - } - } - - /// - /// Compile events expression in GOML attributes - /// - /// Event binding details - public static void CompileEventSource (Binding binding) - { -#if DEBUG_BINDING - Debug.WriteLine ("\tCompile Event Source => " + binding.ToString()); -#endif - - Type target_type = binding.Source.Instance.GetType (); - - #region Retrieve EventHandler parameter type - MethodInfo evtInvoke = binding.Source.Event.EventHandlerType.GetMethod ("Invoke"); - ParameterInfo [] evtParams = evtInvoke.GetParameters (); - Type handlerArgsType = evtParams [1].ParameterType; - #endregion - - Type [] args = { typeof (object), typeof (object), handlerArgsType }; - DynamicMethod dm = new DynamicMethod (binding.CreateNewDynMethodId (), - typeof (void), - args, - target_type); - - - #region IL generation - ILGenerator il = dm.GetILGenerator (256); - - string src = binding.Expression.Trim (); - - if (!(src.StartsWith ("{") || src.EndsWith ("}"))) - throw new Exception (string.Format ("GOML:Malformed {0} Event handler: {1}", binding.Source.Member.Name, binding.Expression)); - - src = src.Substring (1, src.Length - 2); - string [] srcLines = src.Split (new char [] { ';' }); - - foreach (string srcLine in srcLines) { - string statement = srcLine.Trim (); - - string [] operandes = statement.Split (new char [] { '=' }); - if (operandes.Length < 2) //not an affectation - { - continue; - } - string lop = operandes [0].Trim (); - string rop = operandes [operandes.Length - 1].Trim (); - - #region LEFT OPERANDES - GraphicObject lopObj = binding.Source.Instance as GraphicObject; //default left operand base object is - //the first arg (object sender) of the event handler - - il.Emit (OpCodes.Ldarg_0); //load sender ref onto the stack - - string [] lopParts = lop.Split (new char [] { '.' }); - if (lopParts.Length > 1) {//should search also for member of es.Source - for (int j = 0; j < lopParts.Length - 1; j++) { - il.Emit (OpCodes.Ldstr, lopParts [j]); - il.Emit (OpCodes.Callvirt, miFindByName); - } - } - - int i = lopParts.Length - 1; - - MemberInfo [] lopMbis = lopObj.GetType ().GetMember (lopParts [i]); - - if (lopMbis.Length < 1) - throw new Exception (string.Format ("CROW BINDING: Member not found '{0}'", lop)); - - OpCode lopSetOC; - dynamic lopSetMbi; - Type lopT = null; - switch (lopMbis [0].MemberType) { - case MemberTypes.Property: - PropertyInfo lopPi = target_type.GetProperty (lopParts [i]); - MethodInfo dstMi = lopPi.GetSetMethod (); - lopT = lopPi.PropertyType; - lopSetMbi = dstMi; - lopSetOC = OpCodes.Callvirt; - break; - case MemberTypes.Field: - FieldInfo dstFi = target_type.GetField (lopParts [i]); - lopT = dstFi.FieldType; - lopSetMbi = dstFi; - lopSetOC = OpCodes.Stfld; - break; - default: - throw new Exception (string.Format ("GOML:member type not handle: {0}", lopParts [i])); - } - #endregion - - #region RIGHT OPERANDES - if (rop.StartsWith ("\'")) { - if (!rop.EndsWith ("\'")) - throw new Exception (string.Format - ("GOML:malformed string constant in handler: {0}", rop)); - string strcst = rop.Substring (1, rop.Length - 2); - - il.Emit (OpCodes.Ldstr, strcst); - - } else { - if (lopT.IsEnum) - throw new NotImplementedException (); - - MethodInfo lopParseMi = lopT.GetMethod ("Parse"); - if (lopParseMi == null) - throw new Exception (string.Format - ("GOML:no parse method found in: {0}", lopT.Name)); - il.Emit (OpCodes.Ldstr, rop); - il.Emit (OpCodes.Callvirt, lopParseMi); - il.Emit (OpCodes.Unbox_Any, lopT); - } - - #endregion - - //emit left operand assignment - il.Emit (lopSetOC, lopSetMbi); - } - - il.Emit (OpCodes.Ret); - - #endregion - - Delegate del = dm.CreateDelegate (binding.Source.Event.EventHandlerType, binding.Source.Instance); - MethodInfo addHandler = binding.Source.Event.GetAddMethod (); - addHandler.Invoke (binding.Source.Instance, new object [] { del }); - - binding.Resolved = true; - } - #region conversions internal static MethodInfo GetConvertMethod (Type targetType) @@ -696,11 +354,11 @@ namespace Crow } if (tmp != null) return tmp; - if (dstType == typeof(string) || dstType == typeof(object))//TODO:object should be allowed to return null and not "" + if (dstType == typeof(string) || dstType == CompilerServices.TObject)//TODO:object should be allowed to return null and not "" return ""; if (dstType.IsValueType) return Activator.CreateInstance (dstType); - + return null; } public static void emitGetInstance (ILGenerator il, NodeAddress orig, NodeAddress dest){ @@ -711,7 +369,7 @@ namespace Crow break; } for (int i = 0; i < orig.Count - ptr; i++) - il.Emit (OpCodes.Callvirt, typeof(ILayoutable).GetProperty ("LogicalParent").GetGetMethod ()); + il.Emit (OpCodes.Callvirt, CompilerServices.miGetLogicalParent); while (ptr < dest.Count) { emitGetChild (il, dest [ptr-1].CrowType, dest [ptr].Index); ptr++; @@ -725,23 +383,23 @@ namespace Crow } public static void emitGetChild(ILGenerator il, Type parentType, int index){ if (typeof (Group).IsAssignableFrom (parentType)) { - il.Emit (OpCodes.Ldfld, typeof(Group).GetField ("children", BindingFlags.Instance | BindingFlags.NonPublic)); + il.Emit (OpCodes.Ldfld, fiChildren); il.Emit(OpCodes.Ldc_I4, index); - il.Emit (OpCodes.Callvirt, typeof(List).GetMethod("get_Item", new Type[] { typeof(Int32) })); + il.Emit (OpCodes.Callvirt, miGetGObjItem); return; } if (typeof(Container).IsAssignableFrom (parentType) || index < 0) { - il.Emit (OpCodes.Ldfld, typeof(PrivateContainer).GetField ("child", BindingFlags.Instance | BindingFlags.NonPublic)); + il.Emit (OpCodes.Ldfld, fiChild); return; } if (typeof(TemplatedContainer).IsAssignableFrom (parentType)) { - il.Emit (OpCodes.Callvirt, typeof(TemplatedContainer).GetProperty ("Content").GetGetMethod ()); + il.Emit (OpCodes.Callvirt, piContent.GetGetMethod()); return; } if (typeof(TemplatedGroup).IsAssignableFrom (parentType)) { - il.Emit (OpCodes.Callvirt, typeof(TemplatedGroup).GetProperty ("Items").GetGetMethod ()); + il.Emit (OpCodes.Callvirt, miGetItems); il.Emit(OpCodes.Ldc_I4, index); - il.Emit (OpCodes.Callvirt, typeof(List).GetMethod("get_Item", new Type[] { typeof(Int32) })); + il.Emit (OpCodes.Callvirt, miGetGObjItem); return; } } @@ -749,7 +407,7 @@ namespace Crow /// Emit conversion from orig type to dest type /// public static void emitConvert(ILGenerator il, Type origType, Type destType){ - if (destType == typeof(object)) + if (destType == CompilerServices.TObject) return; if (destType == typeof(string)) { System.Reflection.Emit.Label emitNullStr = il.DefineLabel (); @@ -807,10 +465,10 @@ namespace Crow } else{ il.Emit (OpCodes.Stloc_0); //save orig value in loc0 il.Emit (OpCodes.Ldloc_0); - il.Emit (OpCodes.Callvirt, typeof(object).GetMethod ("GetType")); + il.Emit (OpCodes.Callvirt, miGetType); il.Emit (OpCodes.Ldtoken, dstType);//push destination property type for testing il.Emit (OpCodes.Call, CompilerServices.miGetTypeFromHandle); - il.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod ("getImplicitOp", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Call, miGetImplOp); il.Emit (OpCodes.Dup); convert = il.DefineLabel (); il.Emit (OpCodes.Brtrue, convert); @@ -822,12 +480,12 @@ namespace Crow il.MarkLabel (convert); il.Emit (OpCodes.Ldnull);//null instance for invoke il.Emit (OpCodes.Ldc_I4_1); - il.Emit(OpCodes.Newarr, typeof(object)); + il.Emit(OpCodes.Newarr, CompilerServices.TObject); il.Emit (OpCodes.Dup);//duplicate the array ref il.Emit (OpCodes.Ldc_I4_0);//push the index 0 il.Emit (OpCodes.Ldloc_0);//push the orig value to convert - il.Emit (OpCodes.Stelem, typeof(object));//set the array element at index 0 - il.Emit (OpCodes.Callvirt, typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof (object[])})); + il.Emit (OpCodes.Stelem, CompilerServices.TObject);//set the array element at index 0 + il.Emit (OpCodes.Callvirt, miMIInvoke); } il.MarkLabel (endConvert); @@ -917,7 +575,7 @@ namespace Crow Type handlerArgsType = evtParams [1].ParameterType; #endregion - Type [] args = { typeof (object), handlerArgsType }; + Type [] args = { CompilerServices.TObject, handlerArgsType }; DynamicMethod dm = new DynamicMethod ("dyn_eventHandler", typeof(void), args, true); @@ -958,7 +616,7 @@ namespace Crow //named target //TODO: il.Emit(OpCodes.Ldstr, bindTrg[0]); - il.Emit(OpCodes.Callvirt, typeof(GraphicObject).GetMethod("FindByName")); + il.Emit(OpCodes.Callvirt, miFindByName); lopMI = lopType.GetMember (bindTrg [1]).FirstOrDefault(); } else throw new Exception ("Syntax error in binding, expected 'go dot member'"); diff --git a/src/ExtensionsMethods.cs b/src/ExtensionsMethods.cs index 2bfc36ea..5e58cdd5 100644 --- a/src/ExtensionsMethods.cs +++ b/src/ExtensionsMethods.cs @@ -114,18 +114,7 @@ namespace Crow handler(sender, e); } } - /// - /// Type Extension method for Casting - /// - public static object Cast(this Type Type, object data) - { - var DataParam = Expression.Parameter(typeof(object), "data"); - var Body = Expression.Block(Expression.Convert(Expression.Convert(DataParam, data.GetType()), Type)); - var Run = Expression.Lambda(Body, DataParam).Compile(); - var ret = Run.DynamicInvoke(data); - return ret; - } public static bool IsWhiteSpaceOrNewLine (this char c) { return c == '\t' || c == '\r' || c == '\n' || char.IsWhiteSpace (c); diff --git a/src/GraphicObjects/GraphicObject.cs b/src/GraphicObjects/GraphicObject.cs index 61baa267..9c1a8cc4 100644 --- a/src/GraphicObjects/GraphicObject.cs +++ b/src/GraphicObjects/GraphicObject.cs @@ -665,10 +665,10 @@ namespace Crow dm = new DynamicMethod("dyn_loadDefValues", MethodAttributes.Family | MethodAttributes.FamANDAssem | MethodAttributes.NewSlot, CallingConventions.Standard, - typeof(void),new Type[] {typeof(object)},thisType,true); + typeof(void),new Type[] {CompilerServices.TObject},thisType,true); il = dm.GetILGenerator(256); - il.DeclareLocal(typeof(GraphicObject)); + il.DeclareLocal(CompilerServices.TObject); il.Emit(OpCodes.Nop); //set local GraphicObject to root object passed as 1st argument il.Emit (OpCodes.Ldarg_0); @@ -686,13 +686,13 @@ namespace Crow //push eventInfo as 1st arg of compile il.Emit (OpCodes.Ldloc_0); - il.Emit (OpCodes.Call, typeof(object).GetMethod("GetType")); + il.Emit (OpCodes.Call, CompilerServices.miGetType); il.Emit (OpCodes.Ldstr, ei.Name);//push event name - il.Emit (OpCodes.Call, typeof(Type).GetMethod("GetEvent", new Type[] {typeof(string)})); + il.Emit (OpCodes.Call, CompilerServices.miGetEvent); //push expression as 2nd arg of compile il.Emit (OpCodes.Ldstr, trimed.Substring (1, trimed.Length - 2)); il.Emit (OpCodes.Ldnull); - il.Emit (OpCodes.Callvirt, typeof(CompilerServices).GetMethod ("compileDynEventHandler", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Callvirt, CompilerServices.miCompileDynEventHandler); il.Emit (OpCodes.Castclass, ei.EventHandlerType); il.Emit (OpCodes.Callvirt, ei.AddMethod); }else diff --git a/src/IML/Context.cs b/src/IML/Context.cs index 0739dc42..01cfa475 100644 --- a/src/IML/Context.cs +++ b/src/IML/Context.cs @@ -165,9 +165,9 @@ namespace Crow.IML il.Emit(OpCodes.Ldloc_0);//load ref to current graphic object CompilerServices.emitGetInstance (il, address); il.Emit(OpCodes.Ldarg_0);//load ref to this instanciator onto the stack - il.Emit(OpCodes.Ldfld, typeof(Instantiator).GetField("cachedDelegates", BindingFlags.Instance | BindingFlags.NonPublic)); + il.Emit(OpCodes.Ldfld, CompilerServices.fiCachedDel); il.Emit(OpCodes.Ldc_I4, index);//load delegate index - il.Emit(OpCodes.Callvirt, typeof(List).GetMethod("get_Item", new Type[] { typeof(Int32) })); + il.Emit(OpCodes.Callvirt, CompilerServices.miGetDelegateListItem); il.Emit(OpCodes.Callvirt, evt.AddMethod);//call add event } /// @@ -188,16 +188,9 @@ namespace Crow.IML CompilerServices.emitGetInstance (il, bd.TargetNA); //load methodInfo (3rd arg) il.Emit (OpCodes.Ldstr, bd.TargetMember); - //il.Emit (OpCodes.Call, CompilerServices.miGetTypeFromHandle); - - //il.Emit (OpCodes.Pop); - //il.Emit (OpCodes.Pop); - //il.Emit (OpCodes.Pop); - //il.Emit (OpCodes.Pop); - il.Emit (OpCodes.Callvirt, typeof(CompilerServices).GetMethod ("createDel", BindingFlags.Static | BindingFlags.NonPublic)); - //il.Emit (OpCodes.Callvirt, typeof(Delegate).GetMethod ("CreateDelegate", - // new Type[] { typeof(Type), typeof(object), typeof(MethodInfo) }));//create bound delegate - + + il.Emit (OpCodes.Callvirt, CompilerServices.miCreateDel); + il.Emit (OpCodes.Callvirt, bd.SourceEvent.AddMethod);//call add event } diff --git a/src/IML/Node.cs b/src/IML/Node.cs index a9e9bb80..4ba61c03 100644 --- a/src/IML/Node.cs +++ b/src/IML/Node.cs @@ -47,7 +47,7 @@ namespace Crow.IML if (typeof (Container).IsAssignableFrom (CrowType)) return CompilerServices.miSetChild; if (typeof (TemplatedContainer).IsAssignableFrom (CrowType)) - return childIdx < 0 ? CompilerServices.miLoadTmp : CompilerServices.miSetContent; + return childIdx < 0 ? CompilerServices.miLoadTmp : CompilerServices.piContent.GetSetMethod(); if (typeof (TemplatedGroup).IsAssignableFrom (CrowType)) return childIdx < 0 ? CompilerServices.miLoadTmp : CompilerServices.miAddItem; if (typeof (TemplatedControl).IsAssignableFrom (CrowType)) diff --git a/src/Instantiator.cs b/src/Instantiator.cs index 5076b487..e92e8995 100644 --- a/src/Instantiator.cs +++ b/src/Instantiator.cs @@ -110,7 +110,7 @@ namespace Crow ctx.nodesStack.Pop (); foreach (int idx in templateCachedDelegateIndices) - ctx.emitCachedDelegateHandlerAddition(idx, typeof(GraphicObject).GetEvent("LogicalParentChanged")); + ctx.emitCachedDelegateHandlerAddition(idx, CompilerServices.eiLogicalParentChanged); ctx.ResolveNamedTargets (); @@ -450,7 +450,7 @@ namespace Crow il.Emit (OpCodes.Ldarg_2);//load new datasource il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCNewDS); il.Emit (OpCodes.Ldstr, bindingDef.TargetMember);//load handler method name - il.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod ("getMethodInfoWithReflexion", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Call, CompilerServices.miGetMethInfoWithRefx); il.Emit (OpCodes.Stloc_0);//save MethodInfo il.Emit (OpCodes.Ldloc_0);//push mi for test if null @@ -467,8 +467,7 @@ namespace Crow il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCNewDS); il.Emit (OpCodes.Ldloc_0);//load methodInfo (3rd arg) - il.Emit (OpCodes.Callvirt, typeof(Delegate).GetMethod ("CreateDelegate", - new Type[] { typeof(Type), typeof(object), typeof(MethodInfo) }));//create bound delegate + il.Emit (OpCodes.Callvirt, CompilerServices.miCreateBoundDel); il.Emit (OpCodes.Callvirt, sourceEvent.AddMethod);//call add event System.Reflection.Emit.Label finish = il.DefineLabel (); @@ -483,7 +482,7 @@ namespace Crow cachedDelegates.Add (dm.CreateDelegate (CompilerServices.ehTypeDSChange, this)); if (bindingDef.IsDataSourceBinding) - ctx.emitCachedDelegateHandlerAddition (delDSIndex, typeof(GraphicObject).GetEvent ("DataSourceChanged")); + ctx.emitCachedDelegateHandlerAddition (delDSIndex, CompilerServices.eiDSChange); else //template handler binding, will be added to root parentChanged templateCachedDelegateIndices.Add (delDSIndex); } else {//normal in tree handler binding, store until tree is complete (end of parse) @@ -518,7 +517,7 @@ namespace Crow System.Reflection.Emit.Label endMethod = il.DefineLabel (); - il.DeclareLocal (typeof(object)); + il.DeclareLocal (CompilerServices.TObject); il.Emit (OpCodes.Nop); @@ -530,7 +529,7 @@ namespace Crow #region member name test //load source member name il.Emit (OpCodes.Ldarg_1); - il.Emit (OpCodes.Ldfld, typeof(ValueChangeEventArgs).GetField ("MemberName")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCMbName); il.Emit (OpCodes.Ldstr, bindingCase.Key);//load name to test il.Emit (OpCodes.Ldc_I4_4);//StringComparison.Ordinal @@ -553,7 +552,7 @@ namespace Crow if (destination.Count == 0){//template reverse binding //fetch destination instance (which is the template root) for (int j = 0; j < origine.Count ; j++) - il.Emit(OpCodes.Callvirt, typeof(GraphicObject).GetProperty("LogicalParent").GetGetMethod()); + il.Emit(OpCodes.Callvirt, CompilerServices.miGetLogicalParent); }else CompilerServices.emitGetInstance (il, origine, destination); @@ -569,7 +568,7 @@ namespace Crow } //load new value il.Emit (OpCodes.Ldarg_1); - il.Emit (OpCodes.Ldfld, typeof (ValueChangeEventArgs).GetField ("NewValue")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCNewValue); if (origineType == null)//property less binding, no init CompilerServices.emitConvert (il, ma.Property.PropertyType); @@ -583,7 +582,7 @@ namespace Crow ctx.il.Emit (OpCodes.Callvirt, ma.Property.GetSetMethod());//set init value } else {// reverse templateBinding il.Emit (OpCodes.Ldstr, ma.memberName);//arg 3 of setValueWithReflexion - il.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod("setValueWithReflexion", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Call, CompilerServices.miSetValWithRefx); continue; } il.Emit (OpCodes.Callvirt, ma.Property.GetSetMethod());//set value on value changes @@ -601,7 +600,7 @@ namespace Crow //store and emit Add in ctx int dmIdx = cachedDelegates.Count; cachedDelegates.Add (dm.CreateDelegate (typeof(EventHandler))); - ctx.emitCachedDelegateHandlerAddition (dmIdx, typeof(IValueChange).GetEvent ("ValueChanged"), origine); + ctx.emitCachedDelegateHandlerAddition (dmIdx, CompilerServices.eiValueChange, origine); } void emitTemplateBindings(Context ctx, Dictionary> bindings){ //value changed dyn method @@ -620,8 +619,8 @@ namespace Crow System.Reflection.Emit.Label endMethod = il.DefineLabel (); - il.DeclareLocal (typeof(object)); - ilPC.DeclareLocal (typeof(object));//used for checking propery less bindings + il.DeclareLocal (CompilerServices.TObject); + ilPC.DeclareLocal (CompilerServices.TObject);//used for checking propery less bindings ilPC.DeclareLocal (typeof(MemberInfo));//used for checking propery less bindings System.Reflection.Emit.Label cancel = ilPC.DefineLabel (); @@ -629,17 +628,17 @@ namespace Crow #region Unregister previous parent event handler //unregister previous parent handler if not null ilPC.Emit (OpCodes.Ldarg_2);//load old parent - ilPC.Emit (OpCodes.Ldfld, typeof (DataSourceChangeEventArgs).GetField ("OldDataSource")); + ilPC.Emit (OpCodes.Ldfld, CompilerServices.fiDSCOldDS); ilPC.Emit (OpCodes.Brfalse, cancel);//old parent is null ilPC.Emit (OpCodes.Ldarg_2);//load old parent - ilPC.Emit (OpCodes.Ldfld, typeof (DataSourceChangeEventArgs).GetField ("OldDataSource")); + ilPC.Emit (OpCodes.Ldfld, CompilerServices.fiDSCOldDS); //Load cached delegate ilPC.Emit(OpCodes.Ldarg_0);//load ref to this instanciator onto the stack - ilPC.Emit(OpCodes.Ldfld, typeof(Instantiator).GetField("templateBinding", BindingFlags.Instance | BindingFlags.NonPublic)); + ilPC.Emit(OpCodes.Ldfld, CompilerServices.fiTemplateBinding); //add template bindings dynValueChanged delegate to new parent event - ilPC.Emit(OpCodes.Callvirt, typeof(IValueChange).GetEvent("ValueChanged").RemoveMethod);//call remove event + ilPC.Emit(OpCodes.Callvirt, CompilerServices.eiValueChange.RemoveMethod);//call remove event #endregion ilPC.MarkLabel(cancel); @@ -659,7 +658,7 @@ namespace Crow #region member name test //load source member name il.Emit (OpCodes.Ldarg_1); - il.Emit (OpCodes.Ldfld, typeof(ValueChangeEventArgs).GetField ("MemberName")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCMbName); il.Emit (OpCodes.Ldstr, bindingCase.Key);//load name to test il.Emit (OpCodes.Ldc_I4_4);//StringComparison.Ordinal @@ -681,7 +680,7 @@ namespace Crow //get parent type ilPC.Emit (OpCodes.Ldloc_0);//push parent instance ilPC.Emit (OpCodes.Ldstr, bindingCase.Key);//load member name - ilPC.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod("getMemberInfoWithReflexion", BindingFlags.Static | BindingFlags.Public)); + ilPC.Emit (OpCodes.Call, CompilerServices.miGetMembIinfoWithRefx); ilPC.Emit (OpCodes.Stloc_1);//save memberInfo ilPC.Emit (OpCodes.Ldloc_1);//push mi for test if null System.Reflection.Emit.Label propLessReturn = ilPC.DefineLabel (); @@ -701,22 +700,14 @@ namespace Crow //load new value il.Emit (OpCodes.Ldarg_1); - il.Emit (OpCodes.Ldfld, typeof (ValueChangeEventArgs).GetField ("NewValue")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCNewValue); //for the parent changed dyn meth we need to fetch actual value for initialisation thrue reflexion ilPC.Emit (OpCodes.Ldloc_0);//push root instance of instanciator as parentChanged source ilPC.Emit (OpCodes.Ldloc_1);//push mi for value fetching - ilPC.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod("getValueWithReflexion", BindingFlags.Static | BindingFlags.Public)); + ilPC.Emit (OpCodes.Call, CompilerServices.miGetValWithRefx); CompilerServices.emitConvert (il, ma.Property.PropertyType); - - // //box ValueType - // ilPC.Emit (OpCodes.Ldloc_1);//push mi to check if it's a valuetype - // ilPC.Emit (OpCodes.Call, typeof(PropertyInfo).GetProperty("PropertyType").GetGetMethod()); - // ilPC.Emit (OpCodes.Call, typeof(Type).GetProperty("IsValueType").GetGetMethod()); - // System.Reflection.Emit.Label noBoxingRequired = ilPC.DefineLabel (); - // ilPC.Emit (OpCodes.Brfalse, noBoxingRequired); - CompilerServices.emitConvert (ilPC, ma.Property.PropertyType); il.Emit (OpCodes.Callvirt, ma.Property.GetSetMethod()); @@ -745,10 +736,10 @@ namespace Crow //Load cached delegate ilPC.Emit(OpCodes.Ldarg_0);//load ref to this instanciator onto the stack - ilPC.Emit(OpCodes.Ldfld, typeof(Instantiator).GetField("templateBinding", BindingFlags.Instance | BindingFlags.NonPublic)); + ilPC.Emit(OpCodes.Ldfld, CompilerServices.fiTemplateBinding); //add template bindings dynValueChanged delegate to new parent event - ilPC.Emit(OpCodes.Callvirt, typeof(IValueChange).GetEvent("ValueChanged").AddMethod);//call add event + ilPC.Emit(OpCodes.Callvirt, CompilerServices.eiValueChange.AddMethod);//call add event ilPC.MarkLabel (cancel); ilPC.Emit (OpCodes.Ret); @@ -758,7 +749,7 @@ namespace Crow cachedDelegates.Add(dmPC.CreateDelegate (CompilerServices.ehTypeDSChange, this)); #endregion - ctx.emitCachedDelegateHandlerAddition(delDSIndex, typeof(GraphicObject).GetEvent("LogicalParentChanged")); + ctx.emitCachedDelegateHandlerAddition(delDSIndex, CompilerServices.eiLogicalParentChanged); } /// /// create the valuechanged handler, the datasourcechanged handler and emit event handling @@ -781,13 +772,13 @@ namespace Crow System.Reflection.Emit.Label endMethod = il.DefineLabel (); - il.DeclareLocal (typeof(object)); + il.DeclareLocal (CompilerServices.TObject); il.Emit (OpCodes.Nop); //load value changed member name onto the stack il.Emit (OpCodes.Ldarg_2); - il.Emit (OpCodes.Ldfld, CompilerServices.fiMbName); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCMbName); //test if it's the expected one il.Emit (OpCodes.Ldstr, bindingDef.TargetMember); @@ -799,7 +790,7 @@ namespace Crow il.Emit (OpCodes.Ldarg_0); //load new value onto the stack il.Emit (OpCodes.Ldarg_2); - il.Emit (OpCodes.Ldfld, CompilerServices.fiNewValue); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCNewValue); //by default, source value type is deducted from target member type to allow //memberless binding, if targetMember exists, it will be used to determine target @@ -830,7 +821,7 @@ namespace Crow il = dm.GetILGenerator (256); - il.DeclareLocal (typeof(object));//used for checking propery less bindings + il.DeclareLocal (CompilerServices.TObject);//used for checking propery less bindings il.DeclareLocal (typeof(MemberInfo));//used for checking propery less bindings System.Reflection.Emit.Label cancel = il.DefineLabel (); System.Reflection.Emit.Label cancelInit = il.DefineLabel (); @@ -844,15 +835,15 @@ namespace Crow System.Reflection.Emit.Label cancelRemove = il.DefineLabel (); //remove handler if not null il.Emit (OpCodes.Ldarg_2);//load old parent - il.Emit (OpCodes.Ldfld, typeof (DataSourceChangeEventArgs).GetField ("OldDataSource")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCOldDS); il.Emit (OpCodes.Brfalse, cancelRemove);//old parent is null //remove handler il.Emit (OpCodes.Ldarg_2);//1st arg load old datasource - il.Emit (OpCodes.Ldfld, typeof (DataSourceChangeEventArgs).GetField ("OldDataSource")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCOldDS); il.Emit (OpCodes.Ldstr, "ValueChanged");//2nd arg event name il.Emit (OpCodes.Ldarg_1);//3d arg: instance bound to delegate (the source) - il.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod("RemoveEventHandlerByTarget", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Call, CompilerServices.miRemEvtHdlByTarget); il.MarkLabel(cancelRemove); } il.Emit (OpCodes.Ldarg_2);//load datasource change arg @@ -865,7 +856,7 @@ namespace Crow il.Emit (OpCodes.Ldarg_2);//load new datasource il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCNewDS); il.Emit (OpCodes.Ldstr, bindingDef.TargetMember);//load member name - il.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod("getMemberInfoWithReflexion", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Call, CompilerServices.miGetMembIinfoWithRefx); il.Emit (OpCodes.Stloc_1);//save memberInfo il.Emit (OpCodes.Ldloc_1);//push mi for test if null il.Emit (OpCodes.Brfalse, cancelInit);//propertyLessBinding @@ -876,7 +867,7 @@ namespace Crow il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCNewDS); if (!string.IsNullOrEmpty(bindingDef.TargetMember)){ il.Emit (OpCodes.Ldloc_1);//push mi for value fetching - il.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod("getValueWithReflexion", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Call, CompilerServices.miGetValWithRefx); } CompilerServices.emitConvert (il, piSource.PropertyType); il.Emit (OpCodes.Callvirt, piSource.GetSetMethod ()); @@ -895,7 +886,7 @@ namespace Crow il.Emit (OpCodes.Ldarg_2);//load new datasource il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCNewDS); il.Emit(OpCodes.Ldc_I4, dmVC);//load index of dynmathod - il.Emit (OpCodes.Call, typeof(Instantiator).GetMethod("dataSourceChangedEmitHelper", BindingFlags.Instance | BindingFlags.NonPublic)); + il.Emit (OpCodes.Call, CompilerServices.miDSChangeEmitHelper); if (bindingDef.TwoWay){ il.Emit (OpCodes.Ldarg_1);//arg1: dataSourceChange source, the origine of the binding @@ -903,7 +894,7 @@ namespace Crow il.Emit (OpCodes.Ldarg_2);//arg3: new datasource il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCNewDS); il.Emit (OpCodes.Ldstr, bindingDef.TargetMember);//arg4: dest member - il.Emit (OpCodes.Call, typeof(Instantiator).GetMethod("dataSourceReverseBinding", BindingFlags.Static | BindingFlags.NonPublic)); + il.Emit (OpCodes.Call, CompilerServices.miDSReverseBinding); } il.MarkLabel (cancel); @@ -915,7 +906,7 @@ namespace Crow cachedDelegates.Add(dm.CreateDelegate (CompilerServices.ehTypeDSChange, this)); #endregion - ctx.emitCachedDelegateHandlerAddition(delDSIndex, typeof(GraphicObject).GetEvent("DataSourceChanged")); + ctx.emitCachedDelegateHandlerAddition(delDSIndex, CompilerServices.eiDSChange); } /// /// Two way binding for datasource, graphicObj=>dataSource link, datasource value has priority @@ -938,12 +929,12 @@ namespace Crow System.Reflection.Emit.Label endMethod = il.DefineLabel (); - il.DeclareLocal (typeof(object)); + il.DeclareLocal (CompilerServices.TObject); il.Emit (OpCodes.Nop); //load value changed member name onto the stack il.Emit (OpCodes.Ldarg_2); - il.Emit (OpCodes.Ldfld, CompilerServices.fiMbName); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCMbName); //test if it's the expected one il.Emit (OpCodes.Ldstr, origMember); @@ -955,7 +946,7 @@ namespace Crow il.Emit (OpCodes.Ldarg_0); //load new value onto the stack il.Emit (OpCodes.Ldarg_2); - il.Emit (OpCodes.Ldfld, CompilerServices.fiNewValue); + il.Emit (OpCodes.Ldfld, CompilerServices.fiVCNewValue); CompilerServices.emitConvert (il, piOrig.PropertyType, piDest.PropertyType); @@ -974,18 +965,18 @@ namespace Crow System.Reflection.Emit.Label cancel = il.DefineLabel (); il.Emit (OpCodes.Ldarg_2);//load old parent - il.Emit (OpCodes.Ldfld, typeof (DataSourceChangeEventArgs).GetField ("OldDataSource")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCOldDS); il.Emit (OpCodes.Brfalse, cancel);//old parent is null //remove handler if (DSSide){//event is defined in the dataSource instance il.Emit (OpCodes.Ldarg_2);//1st arg load old datasource - il.Emit (OpCodes.Ldfld, typeof (DataSourceChangeEventArgs).GetField ("OldDataSource")); + il.Emit (OpCodes.Ldfld, CompilerServices.fiDSCOldDS); }else//the event is in the source il.Emit (OpCodes.Ldarg_1);//1st arg load old datasource il.Emit (OpCodes.Ldstr, eventName);//2nd arg event name il.Emit (OpCodes.Ldstr, delegateName);//3d arg: delegate name - il.Emit (OpCodes.Call, typeof(CompilerServices).GetMethod("RemoveEventHandlerByName", BindingFlags.Static | BindingFlags.Public)); + il.Emit (OpCodes.Call, CompilerServices.miRemEvtHdlByName); il.MarkLabel(cancel); } diff --git a/src/ItemTemplate.cs b/src/ItemTemplate.cs index bd717f22..1f03f7f8 100644 --- a/src/ItemTemplate.cs +++ b/src/ItemTemplate.cs @@ -65,7 +65,7 @@ namespace Crow ParameterInfo [] evtParams = evtInvoke.GetParameters (); Type handlerArgsType = evtParams [1].ParameterType; - Type [] args = { typeof (object), typeof (object), handlerArgsType }; + Type [] args = { CompilerServices.TObject, CompilerServices.TObject, handlerArgsType }; #region Expand dyn meth //DM is bound to templatedGroup root (arg0) @@ -85,7 +85,7 @@ namespace Crow il.Emit (OpCodes.Ldarg_1);//load sender of expand event il.Emit(OpCodes.Ldstr, "List"); - il.Emit (OpCodes.Callvirt, typeof(GraphicObject).GetMethod("FindByName")); + il.Emit (OpCodes.Callvirt, CompilerServices.miFindByName); il.Emit (OpCodes.Stloc_0); //check that 'Data' of list is not already set @@ -105,7 +105,7 @@ namespace Crow //call 'fetchMethodName' from the dataSource to build the sub nodes list il.Emit (OpCodes.Ldloc_0);//push 'List' (of sub nodes) into the stack il.Emit (OpCodes.Ldarg_1);//get the dataSource of the sender - il.Emit (OpCodes.Callvirt, typeof(GraphicObject).GetProperty("DataSource").GetGetMethod ()); + il.Emit (OpCodes.Callvirt, CompilerServices.miGetDataSource); if (fetchMethodName != "self")//special keyword self allows the use of recurent list<<< emitGetSubData(il, dataType); @@ -122,17 +122,17 @@ namespace Crow #region Items counting dyn method //dm is unbound, arg0 is instance of Item container to expand dm = new DynamicMethod ("dyn_count_" + fetchMethodName, - typeof (bool), new Type[] {typeof(object)}, true); + typeof (bool), new Type[] {CompilerServices.TObject}, true); il = dm.GetILGenerator (256); //get the dataSource of the arg0 il.Emit (OpCodes.Ldarg_0); - il.Emit (OpCodes.Callvirt, typeof(GraphicObject).GetProperty("DataSource").GetGetMethod ()); + il.Emit (OpCodes.Callvirt, CompilerServices.miGetDataSource); if (fetchMethodName != "self") emitGetSubData(il, dataType); - il.Emit (OpCodes.Callvirt, typeof(System.Collections.ICollection).GetProperty("Count").GetGetMethod()); + il.Emit (OpCodes.Callvirt, CompilerServices.miGetColCount); il.Emit (OpCodes.Ldc_I4_0); il.Emit (OpCodes.Cgt); il.Emit (OpCodes.Ret); diff --git a/src/Rectangle.cs b/src/Rectangle.cs index 9a4ef396..3ceb396e 100644 --- a/src/Rectangle.cs +++ b/src/Rectangle.cs @@ -7,6 +7,7 @@ namespace Crow { public struct Rectangle { + internal static Type TRectangle = typeof(Rectangle); #region private fields int _x; int _y; @@ -262,7 +263,7 @@ namespace Crow } public override bool Equals (object obj) { - return (obj == null || obj.GetType() != typeof(Rectangle)) ? + return (obj == null || obj.GetType() != TRectangle) ? false : this == (Rectangle)obj; } diff --git a/src/Size.cs b/src/Size.cs index 5059d31a..996de49f 100644 --- a/src/Size.cs +++ b/src/Size.cs @@ -7,6 +7,7 @@ namespace Crow { public struct Size { + internal static Type TSize = typeof(Size); public static Size Zero { get { return new Size(0, 0); } } @@ -143,7 +144,7 @@ namespace Crow } public override bool Equals (object obj) { - return (obj == null || obj.GetType() != typeof(Size)) ? + return (obj == null || obj.GetType() != TSize) ? false : this == (Size)obj; }