public static Array GetStaticFieldValuesOfType(Type oType, Type oFieldType)
        {
            ArrayBuilder oFieldValues = new ArrayBuilder(oFieldType);

            FieldInfo[] Fields = oType.GetFields(
                BindingFlags.Public |
                BindingFlags.Static |
                BindingFlags.FlattenHierarchy
                );

            ILReflector ILReflector = GetILReflector(oType);

            foreach (FieldInfo oField in Fields)
            {
                object oFieldVal = ILReflector.GetFieldValue(null, oField);

                if (oFieldVal == null)
                {
                    continue;
                }

                if (oFieldType.IsAssignableFrom(oFieldVal.GetType()))
                {
                    oFieldValues.Add(oFieldVal);
                }
            }

            return(oFieldValues.GetArray());
        }
        public static void SetFieldValues(object target, List <object> propValues)
        {
            ILReflector ILReflector = GetILReflector(target.GetType());

            if (ILReflector != null)
            {
                ILReflector.SetFieldValues(target, propValues.ToArray());
            }
        }
        public static List <object> GetFieldValues(object target)
        {
            List <object> propValues = new List <object>();

            ILReflector ILReflector = GetILReflector(target.GetType());

            if (ILReflector != null)
            {
                propValues.AddRange(ILReflector.GetFieldValues(target));
            }

            return(propValues);
        }
        public static object CreateInstance(Type targetType)
        {
            object targetInstance = null;

            ILReflector ILReflector = GetILReflector(targetType);

            if (ILReflector != null)
            {
                targetInstance = ILReflector.CreateInstance();
            }

            return(targetInstance);
        }
        public static object Invoke(MethodInfo method, object target, object[] paramters)
        {
            InvokeMethodDelegate invokeMethod;

            lock (m_locker)
            {
                if (!m_methodsCache.TryGetValue(method, out invokeMethod))
                {
                    invokeMethod = ILReflector.CreateMethodInvoker(method);

                    m_methodsCache.Add(method, invokeMethod);
                }
            }

            return(invokeMethod(target, paramters));
        }
        public static ILReflector GetILReflector(Type reflectedType, BindingFlags bindingFlags, bool serializedFieldsOnly)
        {
            lock (m_locker)
            {
                ILReflector ILReflector = null;

                if (reflectedType != null && !m_allILReflectors.TryGetValue(reflectedType, out ILReflector))
                {
                    ILReflector = CreateILReflector(reflectedType, bindingFlags, serializedFieldsOnly);

                    m_allILReflectors.Add(reflectedType, ILReflector);
                }


                return(ILReflector);
            }
        }
        public static object SetPropertyValue(object target, PropertyInfo propertyInfo, object propertyValue)
        {
            ILReflector ILReflector = GetILReflector(target.GetType());

            return(ILReflector.SetPropertyValue(target, propertyInfo, propertyValue));
        }
        public static object GetFieldValue(object target, FieldInfo fieldInfo)
        {
            ILReflector ILReflector = GetILReflector(target.GetType());

            return(ILReflector.GetFieldValue(target, fieldInfo));
        }
        public static void SetFieldValue(object target, FieldInfo fieldInfo, object fieldValue)
        {
            ILReflector ILReflector = GetILReflector(target.GetType());

            ILReflector.SetFieldValue(target, fieldInfo, fieldValue);
        }