< Summary

Class:GDX.Reflection
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Reflection.cs
Covered lines:112
Uncovered lines:0
Coverable lines:112
Total lines:263
Line coverage:100% (112 of 112)
Covered branches:0
Total branches:0
Covered methods:9
Total methods:9
Method coverage:100% (9 of 9)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
GetDefault(...)0%330100%
GetType(...)0%330100%
InvokeStaticMethod(...)0%440100%
SetFieldOrPropertyValue(...)0%440100%
SetFieldValue(...)0%330100%
SetPropertyValue(...)0%330100%
TryGetFieldValue[T](...)0%330100%
TryGetFieldOrPropertyValue(...)0%440100%
TryGetPropertyValue[T](...)0%330100%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Reflection.cs

#LineLine coverage
 1// Copyright (c) 2020-2022 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using System.Reflection;
 7
 8namespace GDX
 9{
 10    /// <summary>
 11    ///     A collection of reflection related helper utilities.
 12    /// </summary>
 13    /// <remarks>Torn about the existence of this utility class, yet alone the conditions dictating it.</remarks>
 14    public static class Reflection
 15    {
 16        /// <summary>
 17        ///     <see cref="BindingFlags"/> for a private field.
 18        /// </summary>
 19        public const BindingFlags PrivateFieldFlags = BindingFlags.Instance | BindingFlags.NonPublic;
 20        /// <summary>
 21        ///     <see cref="BindingFlags"/> for a private static.
 22        /// </summary>
 23        public const BindingFlags PrivateStaticFlags = BindingFlags.Static | BindingFlags.NonPublic;
 24        /// <summary>
 25        ///     <see cref="BindingFlags"/> for a public static.
 26        /// </summary>
 27        public const BindingFlags PublicStaticFlags = BindingFlags.Static | BindingFlags.Public;
 28
 29        /// <summary>
 30        ///     Returns the default value for a given type.
 31        /// </summary>
 32        /// <param name="type">A qualified type.</param>
 33        /// <returns>The default value.</returns>
 34        public static object GetDefault(this Type type)
 235        {
 236            if (type.IsClass || !type.IsValueType)
 137            {
 138                return null;
 39            }
 140            return Activator.CreateInstance(type);
 241        }
 42
 43        /// <summary>
 44        ///     Returns a qualified type..
 45        /// </summary>
 46        /// <param name="type">The full name of a type.</param>
 47        /// <returns>A <see cref="System.Type"/> if found.</returns>
 48        public static Type GetType(string type)
 2649        {
 2650            Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
 2651            int loadedAssembliesCount = loadedAssemblies.Length;
 448452            for (int i = 0; i < loadedAssembliesCount; i++)
 224053            {
 224054                Type targetType = loadedAssemblies[i].GetType(type);
 224055                if (targetType != null)
 2456                {
 2457                    return targetType;
 58                }
 221659            }
 260            return null;
 2661        }
 62
 63        /// <summary>
 64        ///     Invokes a known static method.
 65        /// </summary>
 66        /// <param name="type">The explicit type of the static class.</param>
 67        /// <param name="method">The name of the method to invoke.</param>
 68        /// <param name="parameters">Any parameters that should be passed to the method?</param>
 69        /// <param name="flags">The <paramref name="method"/>'s access flags.</param>
 70        /// <returns>An <see cref="object"/> of the return value. This can be null.</returns>
 71        public static object InvokeStaticMethod(string type, string method, object[] parameters = null,
 72            BindingFlags flags = PublicStaticFlags)
 373        {
 374            Type targetType = GetType(type);
 375            if (targetType != null)
 276            {
 277                MethodInfo targetMethod = targetType.GetMethod(method, flags);
 278                if (targetMethod != null)
 179                {
 180                    return targetMethod.Invoke(null, parameters ?? Core.EmptyObjectArray);
 81                }
 182            }
 283            return null;
 384        }
 85
 86        /// <summary>
 87        ///     Set the field or property value of a specific <paramref name="targetObject"/>, which may not be
 88        ///     normally accessible.
 89        /// </summary>
 90        /// <param name="targetObject">The instanced object which will have it's field or property value set.</param>
 91        /// <param name="name">The field or property's name to set.</param>
 92        /// <param name="value">The value to set the field or property to.</param>
 93        /// <param name="fieldFlags">The field's access flags.</param>
 94        /// <param name="propertyFlags">The property's access flags.</param>
 95        /// <returns>true/false if the value was set.</returns>
 96        public static bool SetFieldOrPropertyValue(object targetObject, string name, object value,
 97            BindingFlags fieldFlags = PrivateFieldFlags, BindingFlags propertyFlags = PrivateFieldFlags)
 698        {
 699            if (targetObject == null)
 1100                return false;
 101
 5102            Type type = targetObject.GetType();
 5103            FieldInfo f = type.GetField(name, fieldFlags);
 5104            if (f != null)
 2105            {
 2106                f.SetValue(targetObject, value);
 2107                return true;
 108            }
 109
 3110            PropertyInfo p = type.GetProperty(name,propertyFlags);
 3111            if (p != null)
 2112            {
 2113                p.SetValue(targetObject, value);
 2114                return true;
 115            }
 116
 1117            return false;
 6118        }
 119
 120        /// <summary>
 121        ///     Set the field value of a specific <paramref name="targetObject"/>, which may not be normally accessible.
 122        /// </summary>
 123        /// <param name="targetObject">The instanced object which will have it's field value set; use a null value if th
 124        /// <param name="type">The explicit type of the <paramref name="targetObject"/>.</param>
 125        /// <param name="name">The field's name to set.</param>
 126        /// <param name="value">The value to set the field to.</param>
 127        /// <param name="flags">The field's access flags.</param>
 128        /// <returns>true/false if the value was set.</returns>
 129        public static bool SetFieldValue(object targetObject, Type type, string name, object value,
 130            BindingFlags flags = PrivateFieldFlags)
 6131        {
 6132            if (type != null)
 5133            {
 5134                FieldInfo field = type.GetField(name, flags);
 5135                if (field != null)
 4136                {
 4137                    field.SetValue(targetObject, value);
 4138                    return true;
 139                }
 1140            }
 2141            return false;
 6142        }
 143
 144        /// <summary>
 145        ///     Set the property value of a specific <paramref name="targetObject"/>, which may not be normally accessib
 146        /// </summary>
 147        /// <param name="targetObject">The instanced object which will have it's property value set; use a null value if
 148        /// <param name="type">The type of the <paramref name="targetObject"/>.</param>
 149        /// <param name="name">The property's name to set.</param>
 150        /// <param name="value">The value to set the property to.</param>
 151        /// <param name="flags">The property's access flags.</param>
 152        /// <returns>true/false if the value was set.</returns>
 153        public static bool SetPropertyValue(object targetObject, Type type, string name, object value,
 154            BindingFlags flags = PrivateFieldFlags)
 4155        {
 4156            if (type != null)
 3157            {
 3158                PropertyInfo property = type.GetProperty(name, flags);
 3159                if (property != null)
 2160                {
 2161                    property.SetValue(targetObject, value);
 2162                    return true;
 163                }
 1164            }
 2165            return false;
 4166        }
 167
 168        /// <summary>
 169        ///     Try to access the field value of a specific <paramref name="targetObject"/>, which may not be normally a
 170        /// </summary>
 171        /// <remarks></remarks>
 172        /// <param name="targetObject">The instanced object which will have it's field value read; use a null value if t
 173        /// <param name="type">The qualified type of the <paramref name="targetObject"/>.</param>
 174        /// <param name="name">The field's name to read.</param>
 175        /// <param name="returnValue">The returned value from the field, the default value if the field was unable to be
 176        /// <param name="flags">The field's access flags.</param>
 177        /// <typeparam name="T">The type of data being read from the field.</typeparam>
 178        /// <returns>true/false if the process was successful.</returns>
 179        public static bool TryGetFieldValue<T>(object targetObject, Type type, string name, out T returnValue, BindingFl
 7180        {
 7181            if (type == null)
 1182            {
 1183                returnValue = default;
 1184                return false;
 185            }
 6186            FieldInfo fieldInfo = type.GetField(name, flags);
 6187            if (fieldInfo == null)
 1188            {
 1189                returnValue = default;
 1190                return false;
 191            }
 5192            returnValue = (T)fieldInfo.GetValue(targetObject);
 5193            return true;
 7194        }
 195
 196        /// <summary>
 197        ///     Try to access the field or property value of a specific <paramref name="targetObject"/>, which may not
 198        ///     be normally accessible.
 199        /// </summary>
 200        /// <remarks>Useful for when you really do not know the <see cref="System.Type"/>.</remarks>
 201        /// <param name="targetObject">The instanced object which will have it's field or property value read.</param>
 202        /// <param name="name">The field or property's name to read.</param>
 203        /// <param name="returnValue">The returned value from the field or property, the default value if the property w
 204        /// <param name="fieldFlags">The field's access flags.</param>
 205        /// <param name="propertyFlags">The property's access flags.</param>
 206        /// <returns>true/false if a value was found.</returns>
 207        public static bool TryGetFieldOrPropertyValue(object targetObject, string name, out object returnValue,
 208            BindingFlags fieldFlags = PrivateFieldFlags, BindingFlags propertyFlags = PrivateFieldFlags)
 7209        {
 7210            if (targetObject == null)
 1211            {
 1212                returnValue = null;
 1213                return false;
 214            }
 215
 6216            Type type = targetObject.GetType();
 6217            FieldInfo f = type.GetField(name, fieldFlags);
 6218            if (f != null)
 2219            {
 2220                returnValue = f.GetValue(targetObject);
 2221                return true;
 222            }
 223
 4224            PropertyInfo p = type.GetProperty(name,propertyFlags);
 4225            if (p != null)
 3226            {
 3227                returnValue = p.GetValue(targetObject);
 3228                return true;
 229            }
 230
 1231            returnValue = default;
 1232            return false;
 7233        }
 234
 235        /// <summary>
 236        ///     Try to get a property value from <paramref name="targetObject"/>, which may not be normally accessible.
 237        /// </summary>
 238        /// <param name="targetObject">The instanced object which will have it's property value read; use a null value i
 239        /// <param name="type">The explicit type of the <paramref name="targetObject"/>.</param>
 240        /// <param name="name">The property's name to read.</param>
 241        /// <param name="returnValue">The returned value from the property, the default value if the property was unable
 242        /// <param name="flags">The property's access flags.</param>
 243        /// <typeparam name="T">The type of data being read from the property.</typeparam>
 244        /// <returns>true/false if the process was successful.</returns>
 245        public static bool TryGetPropertyValue<T>(object targetObject, Type type, string name, out T returnValue, Bindin
 5246        {
 5247            if (type == null)
 1248            {
 1249                returnValue = default;
 1250                return false;
 251            }
 4252            PropertyInfo propertyInfo = type.GetProperty(name, flags);
 4253            if (propertyInfo == null)
 1254            {
 1255                returnValue = default;
 1256                return false;
 257            }
 258
 3259            returnValue = (T)propertyInfo.GetValue(targetObject);
 3260            return true;
 5261        }
 262    }
 263}