FIX: GetOrSetValueAsync wasn't working when the backing field was inherited and private.

IMP: added another method to format numeric values (UnitFormatter.FormatValue), which should be faster and offers more flexibility.

Author: wokhan

Wokhan.Core/ComponentModel/Extensions/NotifyPropertyChangedExtensions.cs

@@ -58,7 +58,7 @@ public static void SetValue<T>(this INotifyPropertyChanged src, ref T field, T v
     /// <param name="fieldName">For internal use (for reflection, based on the 'targetField' parameter)</param>
     /// <param name="propertyName">For internal use (for reflection, based on the 'targetField' parameter)</param>
     /// <returns></returns>
-    public unsafe static T? GetOrSetValueAsync<T>(this INotifyPropertyChanged src, Func<Task<T>> resolveAsync, ref T targetField, Action<string>? propertyChanged = null, [CallerArgumentExpression(nameof(targetField))] string? fieldName = null, [CallerMemberName] string? propertyName = null)
+    public static T? GetOrSetValueAsync<T>(INotifyPropertyChanged src, Func<Task<T>> resolveAsync, ref T targetField, Action<string>? propertyChanged = null, [CallerArgumentExpression(nameof(targetField))] string? fieldName = null, [CallerMemberName] string? propertyName = null)
     {
         // Dangerous code as it doesn't ensure field has been pinned in memory, resulting in memory violations.
         // Keeping it in case someone has an idea.
@@ -77,18 +77,30 @@ public static void SetValue<T>(this INotifyPropertyChanged src, ref T field, T v
 
         //return field;
 
-
-        fieldName ??= $"<{propertyName}>k_BackingField"; // TODO: check how this is generated. Could be broken with some .NET future implementations.
-        var fieldInfo = src.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
-        if (fieldInfo is null)
-        {
-            throw new ArgumentOutOfRangeException(fieldName);
-        }
+        // Only compute the value if the target (backing) field is null
         if (targetField is null)
         {
+            // TODO: check how this is generated. Could be broken with some .NET future implementations.
+            fieldName ??= $"<{propertyName}>k_BackingField";
+
+            FieldInfo? fieldInfo = null;
+            var type = src.GetType();
+            // Loop over all inherited types if the property cannot be found on the current one
+            while (fieldInfo is null && type is not null)
+            {
+                fieldInfo = type.GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
+                type = type.BaseType;
+            }
+
+            if (fieldInfo is null)
+            {
+                throw new ArgumentOutOfRangeException(fieldName);
+            }
+
             //TODO: check why we are using TaskScheduler.Current and not Default (might cause a thread issue)
             _ = resolveAsync().ContinueWith(task => { fieldInfo.SetValue(src, task.Result); propertyChanged?.Invoke(propertyName!); }, TaskScheduler.Current);
         }
+
         return targetField;
     }
 }

Wokhan.Core/Core/UnitFormatter.cs

@@ -1,10 +1,37 @@
 using System;
 
-namespace Wokhan.Core.Core;
+namespace Wokhan.Core;
 
+/// <summary>
+/// A static class offering a single method to help formatting numeric values.
+/// </summary>
 public static class UnitFormatter
 {
+
+    private static string[] defaultUnits = new[] { "", "K", "M", "G", "T" };
+
+    /// <summary>
+    /// Formats a given value (size, bandwitdth, ...) using the default units (["", "K", "M", "G", "T"]) or the specified one.
+    /// For instance FormatValue(1_000_000, "bps") will return "1Mbps" and FormatValue(2_345_000, units: ["", "KiB", "MiB", "GiB", "TiB"]) will return "2.345MiB".
+    /// </summary>
+    /// <param name="value"></param>
+    /// <param name="suffix">An optional suffix which will get added to the output string (for instance, 'bps').</param>
+    /// <param name="mathBase">An optional mathematical base (1000, 1024) depending on the unit you'll use.</param>
+    /// <param name="units">An array containing the units (related to the base you use).</param>
+    /// <returns></returns>
+    public static string FormatValue(double value, string? suffix = null, int mathBase = 1000, string[]? units = null)
+    {
+        units ??= defaultUnits;
+
+        var num = Math.Max(0, Math.Min(units.Length - 1, (int)Math.Log(value, mathBase)));
+        value = (int)(value / Math.Pow(mathBase, num) * 100) / 100;
+
+        return $"{value:#0.##}{units[num]}{suffix}";
+    }
+
     static string[] units = new[] { "B", "KiB", "MiB", "GiB", "TiB" };
+
+    [Obsolete("This method has been deprecated. Please use FormatUnit instead.")]
     public static string FormatBytes(double size, string? suffix = null)
     {
         int i;