Added more extension

Author: VikashChauhan51

.github/workflows/build.yml

@@ -7,7 +7,7 @@ on:
     types: [opened, synchronize, reopened]
 
 env:
-  DOTNET_VERSION: '7.0.x' # The .NET SDK version to use
+  DOTNET_VERSION: '8.0.x' # The .NET SDK version to use
 
 jobs:
   build-and-test:

.github/workflows/package.yaml

@@ -14,7 +14,7 @@ jobs:
     - name: Setup .NET Core
       uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: 7.0.x
+        dotnet-version: 8.0.x
     - name: Install dependencies
       run: dotnet restore
       working-directory: src

src/Reflector/CastExtensions.cs

@@ -1,4 +1,5 @@
-using System.Reflection;
+using System.Globalization;
+using System.Reflection;
 
 namespace Reflector;
 
@@ -8,6 +9,95 @@ public static class CastExtensions
     private const string ImplicitCastMethodName = "op_Implicit";
     private const string ExplicitCastMethodName = "op_Explicit";
 
+    public static T? SafeCast<T>(this object obj) where T : class
+    {
+        return obj as T;
+    }
+
+    public static T CastOrDefault<T>(this object obj, T defaultValue = default)
+    {
+        try
+        {
+            return (T)obj;
+        }
+        catch
+        {
+            return defaultValue;
+        }
+    }
+
+    public static bool TryCast<T>(this object obj, out T? result) where T : class
+    {
+        if (obj == null)
+        {
+            result = default;
+            return false;
+        }
+
+        if (obj is T castedObj)
+        {
+            result = castedObj;
+            return true;
+        }
+
+        if (obj.CanExplicitCast<T>())
+        {
+            result = obj.ExplicitCast<T>();
+            return true;
+        }
+
+        result = default;
+        return false;
+    }
+
+
+    public static Func<T, T, bool> GetComparer<T>()
+    {
+        if (typeof(T).IsValueType)
+        {
+            // Avoid causing any boxing for value types
+            return (actual, expected) => EqualityComparer<T>.Default.Equals(actual, expected);
+        }
+
+        if (typeof(T) != typeof(object))
+        {
+            // CompareNumerics is only relevant for numerics boxed in an object.
+            return (actual, expected) => actual is null
+                ? expected is null
+                : expected is not null && EqualityComparer<T>.Default.Equals(actual, expected);
+        }
+
+        return (actual, expected) => actual is null
+            ? expected is null
+            : expected is not null
+            && (EqualityComparer<T>.Default.Equals(actual, expected) || CompareNumerics(actual, expected));
+    }
+
+    public static bool IsCastableTo<T>(this object obj)
+    {
+        return obj is T || obj.GetType().CanCast<T>();
+    }
+
+    public static bool CheckCastCompatibility(this Type sourceType, Type targetType)
+    {
+        return sourceType.IsAssignableFrom(targetType) || targetType.IsAssignableFrom(sourceType);
+    }
+
+    public static bool CanConvert(object source, object target, Type sourceType, Type targetType)
+    {
+        try
+        {
+            var converted = source.ConvertTo(targetType);
+
+            return source.Equals(converted.ConvertTo(sourceType))
+                && converted.Equals(target);
+        }
+        catch
+        {
+            // Ignored
+            return false;
+        }
+    }
     public static bool CanCast<T>(this Type baseType)
     {
         return baseType.CanImplicitCast<T>() || baseType.CanExplicitCast<T>();
@@ -65,7 +155,7 @@ private static bool CanCast<T>(this Type baseType, string castMethodName)
             .Where(mi => mi.Name == castMethodName && mi.ReturnType == targetType)
             .Any(mi =>
             {
-                ParameterInfo pi = mi.GetParameters().FirstOrDefault();
+                ParameterInfo? pi = mi.GetParameters().FirstOrDefault();
                 return pi != null && pi.ParameterType == baseType;
             });
     }
@@ -87,13 +177,31 @@ private static T Cast<T>(this object obj, string castMethodName)
             .Where(mi => mi.Name == castMethodName && mi.ReturnType == typeof(T))
             .SingleOrDefault(mi =>
             {
-                ParameterInfo pi = mi.GetParameters().FirstOrDefault();
+                ParameterInfo? pi = mi.GetParameters().FirstOrDefault();
                 return pi != null && pi.ParameterType == objType;
             });
         if (conversionMethod != null)
-            return (T)conversionMethod.Invoke(null, new[] { obj });
+            return (T)conversionMethod.Invoke(null, new[] { obj })!;
         else
             throw new InvalidCastException($"No method to cast {objType.FullName} to {typeof(T).FullName}");
     }
+
+    private static bool CompareNumerics(object actual, object expected)
+    {
+        Type expectedType = expected.GetType();
+        Type actualType = actual.GetType();
+
+        return actualType != expectedType
+            && actual.IsNumericType()
+            && expected.IsNumericType()
+            && CanConvert(actual, expected, actualType, expectedType)
+            && CanConvert(expected, actual, expectedType, actualType);
+    }
+
+
+    private static object ConvertTo(this object source, Type targetType)
+    {
+        return Convert.ChangeType(source, targetType, CultureInfo.InvariantCulture);
+    }
 }
 

src/Reflector/ReflectionExtensions.cs

@@ -105,6 +105,21 @@ public static bool IsPrimitive(this Type type)
             || Convert.GetTypeCode(type) != TypeCode.Object);
     }
 
+    public static bool IsNumericType(this object obj)
+    {
+        return obj is (
+            int or
+            long or
+            float or
+            double or
+            decimal or
+            sbyte or
+            byte or
+            short or
+            ushort or
+            uint or
+            ulong);
+    }
     public static object? InvokeStaticMethod(this Type type, string name, params object[] args)
     {
         return type?.GetTypeInfo().InvokeMember(

src/Reflector/SpanReflectionExtensions.cs

@@ -0,0 +1,62 @@
+namespace VReflector;
+
+public static class SpanReflectionExtensions
+{
+
+    /// <summary>
+    /// Converts a ReadOnlySpan<char> to a string using reflection.
+    /// Useful when dealing with Spans in scenarios where a string is needed.
+    /// </summary>
+    /// <param name="span">The ReadOnlySpan to convert.</param>
+    /// <returns>A string representation of the span.</returns>
+    public static string ToStringViaReflector(ReadOnlySpan<char> span)
+    {
+        // Use the ReadOnlySpan<char> constructor of string if available
+        return new string(span);
+    }
+
+    /// <summary>
+    /// Compares two spans character by character for equality.
+    /// </summary>
+    /// <param name="span1">The first span.</param>
+    /// <param name="span2">The second span.</param>
+    /// <returns>True if the spans are equal; otherwise, false.</returns>
+    public static bool AreSpansEqual(ReadOnlySpan<char> span1, ReadOnlySpan<char> span2)
+    {
+        return span1.SequenceEqual(span2);
+    }
+
+    /// <summary>
+    /// Extracts a substring from a ReadOnlySpan<char>.
+    /// </summary>
+    /// <param name="span">The span to extract from.</param>
+    /// <param name="start">The start index.</param>
+    /// <param name="length">The length of the substring.</param>
+    /// <returns>A string representation of the extracted substring.</returns>
+    public static string Substring(ReadOnlySpan<char> span, int start, int length)
+    {
+        return new string(span.Slice(start, length));
+    }
+
+    /// <summary>
+    /// Reflectively analyzes the contents of a span for debugging or logging.
+    /// </summary>
+    /// <param name="span">The span to analyze.</param>
+    /// <returns>A string representing the span's contents.</returns>
+    public static string Analyze(ReadOnlySpan<char> span)
+    {
+        return $"Span Length: {span.Length}, Contents: '{new string(span)}'";
+    }
+
+    /// <summary>
+    /// Converts any Span<T> to a human-readable format for debugging.
+    /// </summary>
+    /// <typeparam name="T">The type of the span elements.</typeparam>
+    /// <param name="span">The span to convert.</param>
+    /// <returns>A string representation of the span's contents.</returns>
+    public static string ToDebugString<T>(ReadOnlySpan<T> span)
+    {
+        return $"[ {string.Join(", ", span.ToArray())} ]";
+    }
+
+}

src/Reflector/VReflector.csproj

@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <VersionPrefix>1.4.0</VersionPrefix>
+    <VersionPrefix>1.5.0</VersionPrefix>
     <SignAssembly>True</SignAssembly>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>VReflector</Title>