refactor logger creation to use type-utils for improved type name handling

Author: fembina

Sources/Falko.ZeroLogger.Microsoft.Logging/Loggers/MicrosoftLogger{T}.cs

@@ -6,14 +6,11 @@ public sealed class MicrosoftLogger<TTarget> : ILogger<TTarget>
 {
     private readonly IMicrosoftLogger _logger;
 
+    // ReSharper disable once ConvertToPrimaryConstructor
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public MicrosoftLogger(IMicrosoftLoggerFactory loggerFactory)
     {
-        var loggerName = typeof(TTarget).FullName;
-
-        ArgumentException.ThrowIfNullOrEmpty(loggerName);
-
-        _logger = loggerFactory.CreateLogger(loggerName);
+        _logger = loggerFactory.CreateLogger<TTarget>();
     }
 
     public void Log<TState>

Sources/Falko.ZeroLogger/Factories/LoggerFactory.cs

@@ -1,5 +1,6 @@
 using System.Logging.Loggers;
 using System.Logging.Runtimes;
+using System.Logging.Utils;
 
 namespace System.Logging.Factories;
 
@@ -17,7 +18,7 @@ public Logger CreateLogger(string name)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public Logger CreateLogger<T>() where T : notnull
     {
-        var name = typeof(T).FullName;
+        var name = TypeUtils.GetTypeName(typeof(T));
 
         ArgumentNullException.ThrowIfNull(name);
 
@@ -29,7 +30,7 @@ public Logger CreateLogger(Type type)
     {
         ArgumentNullException.ThrowIfNull(type);
 
-        var name = type.FullName;
+        var name = TypeUtils.GetTypeName(type);
 
         ArgumentNullException.ThrowIfNull(name);
 

Sources/Falko.ZeroLogger/Utils/TypeUtils.cs

@@ -0,0 +1,68 @@
+using System.Logging.Builders;
+
+namespace System.Logging.Utils;
+
+internal static class TypeUtils
+{
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static string GetTypeName(Type type)
+    {
+        var nameBuilder = new ValueStringBuilder(stackalloc char[256]);
+
+        try
+        {
+            GetTypeName(type, ref nameBuilder);
+            return nameBuilder.ToString();
+        }
+        finally
+        {
+            nameBuilder.Dispose();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void GetTypeName(Type type, ref ValueStringBuilder nameBuilder)
+    {
+        var name = type.FullName ?? type.Name;
+        var nameLength = name.Length;
+
+        if (type.IsGenericType is false)
+        {
+            nameBuilder.Ensure(nameLength);
+            nameBuilder.Append(name);
+
+            return;
+        }
+
+        var index = name.IndexOf('`');
+
+        if (index <= 0)
+        {
+            nameBuilder.Ensure(nameLength);
+            nameBuilder.Append(name);
+
+            return;
+        }
+
+        scoped ReadOnlySpan<char> shortName = name.AsSpan(0, index);
+
+        nameBuilder.Ensure(shortName.Length + 2);
+        nameBuilder.Append(shortName);
+        nameBuilder.Append('<');
+
+        scoped ReadOnlySpan<Type> genericArguments = type.GetGenericArguments();
+
+        for (var i = 0; i < genericArguments.Length; i++)
+        {
+            if (i > 0)
+            {
+                nameBuilder.Append(',');
+                nameBuilder.Append(' ');
+            }
+
+            GetTypeName(genericArguments[i], ref nameBuilder);
+        }
+
+        nameBuilder.Append('>');
+    }
+}