Add extension for getting nullable type cached

osu.Framework/Allocation/DependencyContainer.cs

···
                 throw new ArgumentNullException(nameof(instance));
             }
 
-            info = info.WithType(Nullable.GetUnderlyingType(type) ?? type);
+            info = info.WithType(type.GetUnderlyingNullableType() ?? type);
 
             var instanceType = instance.GetType();
-            instanceType = Nullable.GetUnderlyingType(instanceType) ?? instanceType;
+            instanceType = instanceType.GetUnderlyingNullableType() ?? instanceType;
 
             if (instanceType.IsValueType && !allowValueTypes)
                 throw new ArgumentException($"{instanceType.ReadableName()} must be a class to be cached as a dependency.", nameof(instance));
···
 
         public object Get(Type type, CacheInfo info)
         {
-            info = info.WithType(Nullable.GetUnderlyingType(type) ?? type);
+            info = info.WithType(type.GetUnderlyingNullableType() ?? type);
 
             if (cache.TryGetValue(info, out var existing))
                 return existing;

osu.Framework/Bindables/Bindable.cs

···
 using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Caching;
+using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.IO.Serialization;
 using osu.Framework.Lists;
 
···
         /// <param name="input">The input which is to be parsed.</param>
         public virtual void Parse(object input)
         {
-            Type underlyingType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
+            Type underlyingType = typeof(T).GetUnderlyingNullableType() ?? typeof(T);
 
             switch (input)
             {

osu.Framework/Extensions/TypeExtensions/TypeExtensions.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
···
             return ret;
         }
 
+        private static readonly ConcurrentDictionary<Type, Type> underlying_type_cache = new ConcurrentDictionary<Type, Type>();
+
         /// <summary>
         /// Determines whether the specified type is a <see cref="Nullable{T}"/> type.
         /// </summary>
         /// <remarks>See: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type</remarks>
-        public static bool IsNullable(this Type type) => type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
+        public static bool IsNullable(this Type type) => type.GetUnderlyingNullableType() != null;
+
+        /// <summary>
+        /// Gets the underlying type of a <see cref="Nullable{T}"/>.
+        /// </summary>
+        /// <remarks>This method is cached.</remarks>
+        /// <param name="type">The potentially nullable type.</param>
+        /// <returns>The underlying type, or null if one does not exist.</returns>
+        public static Type GetUnderlyingNullableType(this Type type)
+        {
+            if (!type.IsGenericType)
+                return null;
+
+            // ReSharper disable once ConvertClosureToMethodGroup (see: https://github.com/dotnet/runtime/issues/33747)
+            return underlying_type_cache.GetOrAdd(type, t => Nullable.GetUnderlyingType(t));
+        }
     }
 
     [Flags]