public _Cache_(Type targetType) { if (targetType == null) { return; } foreach (FieldInfo field in targetType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) { string name = field.Name; Getters[name] = (obj) => field.GetValue(obj); Setters[name] = (obj, value) => field.SetValue(obj, value); } foreach (PropertyInfo prop in targetType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) { string name = prop.Name; MethodInfo get = prop.GetGetMethod(true); if (get != null) { Getters[name] = (obj) => get.Invoke(obj, _NoArgs); } MethodInfo set = prop.GetSetMethod(true); if (set != null) { Setters[name] = (obj, value) => set.Invoke(obj, new object[] { value }); } } Dictionary <string, MethodInfo> methods = new Dictionary <string, MethodInfo>(); foreach (MethodInfo method in targetType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) { string name = method.Name; if (methods.ContainsKey(name)) { methods[name] = null; } else { methods[name] = method; } } foreach (KeyValuePair <string, MethodInfo> kvp in methods) { if (kvp.Value == null) { continue; } FastReflectionDelegate cb = kvp.Value.GetFastDelegate(); Methods[kvp.Key] = (target, args) => cb(target, args); } }
public RandomizerCallStaticMethod(Type t, string methodName, params object[] parameters) { MethodInfo info = t.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (info == null) { throw new ArgumentException($"Class {t} has no static method {methodName}"); } _method = info.CreateFastDelegate(); _parameters = parameters; }
internal CachedProperty(PropertyInfo propertyInfo) { if (propertyInfo.CanRead) { _get = CustomFastReflectionHelper.CreateFastDelegate(propertyInfo.GetGetMethod(true)); } if (propertyInfo.CanWrite) { _set = CustomFastReflectionHelper.CreateFastDelegate(propertyInfo.GetSetMethod(true)); } PropertyType = propertyInfo.PropertyType; }
static DynData() { _DataHelper_.Collected += () => { HashSet <WeakReference> dead = new HashSet <WeakReference>(); foreach (WeakReference weak in _DataMap.Keys) { if (!weak.IsAlive) { dead.Add(weak); } } foreach (WeakReference weak in dead) { _DataMap.Remove(weak); } }; // TODO: Use DynamicMethod to generate more performant getters and setters. foreach (FieldInfo field in typeof(TTarget).GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) { string name = field.Name; _SpecialGetters[name] = (obj) => field.GetValue(obj); _SpecialSetters[name] = (obj, value) => field.SetValue(obj, value); } foreach (PropertyInfo prop in typeof(TTarget).GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)) { string name = prop.Name; MethodInfo get = prop.GetGetMethod(true); if (get != null) { FastReflectionDelegate getFast = get.CreateFastDelegate(true); _SpecialGetters[name] = (obj) => getFast(obj); } MethodInfo set = prop.GetSetMethod(true); if (set != null) { FastReflectionDelegate setFast = set.CreateFastDelegate(true); _SpecialSetters[name] = (obj, value) => setFast(obj, value); } } }
public BepInExLogger(string source) : base(source) { var staticFlags = BindingFlags.Static | BindingFlags.Public; var instanceFlags = BindingFlags.Instance | BindingFlags.Public; var logLevelType = Type.GetType("BepInEx.Logging.LogLevel, BepInEx", false); if (logLevelType == null) { throw new Exception("BepInEx is not loaded!"); } var manualLogSourceType = Type.GetType("BepInEx.Logging.ManualLogSource, BepInEx", false); if (manualLogSourceType != null) { var loggerType = Type.GetType("BepInEx.Logging.Logger, BepInEx", false); var createLogSourceMethod = loggerType.GetMethod("CreateLogSource", staticFlags, null, new[] { typeof(string) }, null); _logObject = createLogSourceMethod.Invoke(null, new object[] { Source }); var logMethod = _logObject.GetType().GetMethod("Log", instanceFlags, null, new[] { logLevelType, typeof(object) }, null); _logMethod = CustomFastReflectionHelper.CreateFastDelegate(logMethod); } else { var loggerType = Type.GetType("BepInEx.Logger, BepInEx", false); _logObject = loggerType.GetProperty("CurrentLogger", staticFlags).GetValue(null, null); var logMethod = _logObject.GetType().GetMethod("Log", instanceFlags, null, new[] { logLevelType, typeof(object) }, null); _logMethod = CustomFastReflectionHelper.CreateFastDelegate(logMethod); } if (_logMethod == null) { throw new Exception("BepInEx is not loaded!"); } }
/// <inheritdoc /> /// <summary> /// Constructs the mod, assigns the instance and sets the name. /// </summary> protected Mod(string name = null) { if (string.IsNullOrEmpty(name)) { name = GetType().Name; } if ( this.GetType() .GetInterfaces() .FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IGlobalSettings <>)) is Type globalType ) { this.globalSettingsType = globalType.GetGenericArguments()[0]; foreach (var mi in globalType.GetMethods()) { switch (mi.Name) { case nameof(IGlobalSettings <object> .OnLoadGlobal): this.onLoadGlobalSettings = mi.GetFastDelegate(); break; case nameof(IGlobalSettings <object> .OnSaveGlobal): this.onSaveGlobalSettings = mi.GetFastDelegate(); break; } } } if ( this.GetType() .GetInterfaces() .FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ILocalSettings <>)) is Type saveType ) { this.saveSettingsType = saveType.GetGenericArguments()[0]; foreach (var mi in saveType.GetMethods()) { switch (mi.Name) { case nameof(ILocalSettings <object> .OnLoadLocal): this.onLoadSaveSettings = mi.GetFastDelegate(); break; case nameof(ILocalSettings <object> .OnSaveLocal): this.onSaveSaveSettings = mi.GetFastDelegate(); break; } } } Name = name; Log("Initializing"); _globalSettingsPath ??= Path.Combine(Application.persistentDataPath, $"{GetType().Name}.GlobalSettings.json"); LoadGlobalSettings(); HookSaveMethods(); }
internal CachedMethod(MethodInfo method) { _invoke = CustomFastReflectionHelper.CreateFastDelegate(method); }