chore: add additional nullable annotations

filzrev · filzrev · commit d7ebe522f545 · 2025-12-07T10:08:09.000+09:00
diff --git a/src/BenchmarkDotNet/Characteristics/CharacteristicObject.cs b/src/BenchmarkDotNet/Characteristics/CharacteristicObject.cs
@@ -5,6 +5,8 @@
 using System.Reflection;
 using JetBrains.Annotations;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Characteristics
 {
     // TODO: better naming.
@@ -17,10 +19,10 @@ public abstract class CharacteristicObject
             DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties
             | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields;
 
-        protected static string ResolveId(CharacteristicObject obj, string actual)
+        protected static string ResolveId(CharacteristicObject obj, string? actual)
         {
             if (!string.IsNullOrEmpty(actual) && actual != IdCharacteristic.FallbackValue)
-                return actual;
+                return actual!;
 
             string result = CharacteristicSetPresenter.Display.ToPresentation(obj);
 
@@ -160,22 +162,22 @@ public bool HasValue(Characteristic characteristic)
         #endregion
 
         #region Resolve
-        public T ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver)
+        public T? ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver)
         {
             return resolver.Resolve(this, characteristic);
         }
 
-        public T ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver, T defaultValue)
+        public T? ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver, T defaultValue)
         {
             return resolver.Resolve(this, characteristic, defaultValue);
         }
 
-        public object ResolveValue(Characteristic characteristic, IResolver resolver)
+        public object? ResolveValue(Characteristic characteristic, IResolver resolver)
         {
             return resolver.Resolve(this, characteristic);
         }
 
-        public object ResolveValue(Characteristic characteristic, IResolver resolver, object defaultValue)
+        public object? ResolveValue(Characteristic characteristic, IResolver resolver, object defaultValue)
         {
             return resolver.Resolve(this, characteristic, defaultValue);
         }
diff --git a/src/BenchmarkDotNet/Characteristics/CompositeResolver.cs b/src/BenchmarkDotNet/Characteristics/CompositeResolver.cs
@@ -2,6 +2,8 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Characteristics
 {
     public class CompositeResolver : IResolver
@@ -15,7 +17,7 @@ public CompositeResolver(params IResolver[] resolvers)
 
         public bool CanResolve(Characteristic characteristic) => resolvers.Any(r => r.CanResolve(characteristic));
 
-        public object Resolve(CharacteristicObject obj, Characteristic characteristic)
+        public object? Resolve(CharacteristicObject obj, Characteristic characteristic)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
@@ -26,7 +28,7 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic)
             throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");
         }
 
-        public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)
+        public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
@@ -37,7 +39,7 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic)
             throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");
         }
 
-        public object Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)
+        public object? Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
@@ -48,7 +50,7 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic, o
             return defaultValue;
         }
 
-        public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)
+        public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
diff --git a/src/BenchmarkDotNet/Characteristics/IResolver.cs b/src/BenchmarkDotNet/Characteristics/IResolver.cs
@@ -1,5 +1,7 @@
 ﻿using System.Diagnostics.CodeAnalysis;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Characteristics
 {
     /// <summary>
@@ -9,12 +11,12 @@ public interface IResolver
     {
         bool CanResolve(Characteristic characteristic);
 
-        object Resolve(CharacteristicObject obj, Characteristic characteristic);
+        object? Resolve(CharacteristicObject obj, Characteristic characteristic);
 
-        T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic);
+        T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic);
 
-        object Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue);
+        object? Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue);
 
-        T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue);
+        T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue);
     }
 }
diff --git a/src/BenchmarkDotNet/Characteristics/Resolver.cs b/src/BenchmarkDotNet/Characteristics/Resolver.cs
@@ -2,21 +2,23 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Characteristics
 {
     public class Resolver : IResolver
     {
-        private readonly Dictionary<Characteristic, Func<CharacteristicObject, object>> resolvers = new Dictionary<Characteristic, Func<CharacteristicObject, object>>();
+        private readonly Dictionary<Characteristic, Func<CharacteristicObject, object?>> resolvers = new Dictionary<Characteristic, Func<CharacteristicObject, object?>>();
 
-        protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<T> resolver) =>
+        protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<T?> resolver) =>
             resolvers[characteristic] = obj => resolver();
 
-        protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<CharacteristicObject, T> resolver) =>
+        protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<CharacteristicObject, T?> resolver) =>
             resolvers[characteristic] = obj => resolver(obj);
 
         public bool CanResolve(Characteristic characteristic) => resolvers.ContainsKey(characteristic);
 
-        public object Resolve(CharacteristicObject obj, Characteristic characteristic)
+        public object? Resolve(CharacteristicObject obj, Characteristic characteristic)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
@@ -26,17 +28,17 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic)
             throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");
         }
 
-        public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)
+        public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
 
             if (resolvers.TryGetValue(characteristic, out var resolver))
-                return (T)resolver(obj);
+                return (T?)resolver(obj);
             throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");
         }
 
-        public object Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)
+        public object? Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
@@ -47,13 +49,13 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic, o
             return defaultValue;
         }
 
-        public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)
+        public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)
         {
             if (obj.HasValue(characteristic))
                 return characteristic[obj];
 
             if (resolvers.TryGetValue(characteristic, out var resolver))
-                return (T)resolver(obj);
+                return (T?)resolver(obj);
 
             return defaultValue;
         }
diff --git a/src/BenchmarkDotNet/Diagnosers/ThreadingDiagnoser.cs b/src/BenchmarkDotNet/Diagnosers/ThreadingDiagnoser.cs
@@ -47,7 +47,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara
             {
                 var runtime = benchmark.Job.ResolveValue(EnvironmentMode.RuntimeCharacteristic, EnvironmentResolver.Instance);
 
-                if (runtime.RuntimeMoniker < RuntimeMoniker.NetCoreApp30)
+                if (runtime != null && runtime.RuntimeMoniker < RuntimeMoniker.NetCoreApp30)
                 {
                     yield return new ValidationError(true, $"{nameof(ThreadingDiagnoser)} supports only .NET Core 3.0+", benchmark);
                 }
diff --git a/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs b/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs
@@ -34,7 +34,7 @@ internal static IToolchain GetToolchain(this Job job)
             => job.Infrastructure.TryGetToolchain(out var toolchain)
                 ? toolchain
                 : GetToolchain(
-                    job.ResolveValue(EnvironmentMode.RuntimeCharacteristic, EnvironmentResolver.Instance),
+                    job.ResolveValue(EnvironmentMode.RuntimeCharacteristic, EnvironmentResolver.Instance)!,
                     null,
                     job.HasDynamicBuildCharacteristic(),
                     job.Environment.HasValue(EnvironmentMode.RuntimeCharacteristic)

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,8 @@`
`5`	`5`	`using System.Reflection;`
`6`	`6`	`using JetBrains.Annotations;`
`7`	`7`
	`8`	`+#nullable enable`
	`9`	`+`
`8`	`10`	`namespace BenchmarkDotNet.Characteristics`
`9`	`11`	`{`
`10`	`12`	`// TODO: better naming.`
`@@ -17,10 +19,10 @@ public abstract class CharacteristicObject`
`17`	`19`	`DynamicallyAccessedMemberTypes.PublicProperties \| DynamicallyAccessedMemberTypes.NonPublicProperties`
`18`	`20`	`\| DynamicallyAccessedMemberTypes.PublicFields \| DynamicallyAccessedMemberTypes.NonPublicFields;`
`19`	`21`
`20`		`- protected static string ResolveId(CharacteristicObject obj, string actual)`
	`22`	`+ protected static string ResolveId(CharacteristicObject obj, string? actual)`
`21`	`23`	`{`
`22`	`24`	`if (!string.IsNullOrEmpty(actual) && actual != IdCharacteristic.FallbackValue)`
`23`		`- return actual;`
	`25`	`+ return actual!;`
`24`	`26`
`25`	`27`	`string result = CharacteristicSetPresenter.Display.ToPresentation(obj);`
`26`	`28`
`@@ -160,22 +162,22 @@ public bool HasValue(Characteristic characteristic)`
`160`	`162`	`#endregion`
`161`	`163`
`162`	`164`	`#region Resolve`
`163`		`- public T ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver)`
	`165`	`+ public T? ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver)`
`164`	`166`	`{`
`165`	`167`	`return resolver.Resolve(this, characteristic);`
`166`	`168`	`}`
`167`	`169`
`168`		`- public T ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver, T defaultValue)`
	`170`	`+ public T? ResolveValue<[DynamicallyAccessedMembers(CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, IResolver resolver, T defaultValue)`
`169`	`171`	`{`
`170`	`172`	`return resolver.Resolve(this, characteristic, defaultValue);`
`171`	`173`	`}`
`172`	`174`
`173`		`- public object ResolveValue(Characteristic characteristic, IResolver resolver)`
	`175`	`+ public object? ResolveValue(Characteristic characteristic, IResolver resolver)`
`174`	`176`	`{`
`175`	`177`	`return resolver.Resolve(this, characteristic);`
`176`	`178`	`}`
`177`	`179`
`178`		`- public object ResolveValue(Characteristic characteristic, IResolver resolver, object defaultValue)`
	`180`	`+ public object? ResolveValue(Characteristic characteristic, IResolver resolver, object defaultValue)`
`179`	`181`	`{`
`180`	`182`	`return resolver.Resolve(this, characteristic, defaultValue);`
`181`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`	`using System.Diagnostics.CodeAnalysis;`
`3`	`3`	`using System.Linq;`
`4`	`4`
	`5`	`+#nullable enable`
	`6`	`+`
`5`	`7`	`namespace BenchmarkDotNet.Characteristics`
`6`	`8`	`{`
`7`	`9`	`public class CompositeResolver : IResolver`
`@@ -15,7 +17,7 @@ public CompositeResolver(params IResolver[] resolvers)`
`15`	`17`
`16`	`18`	`public bool CanResolve(Characteristic characteristic) => resolvers.Any(r => r.CanResolve(characteristic));`
`17`	`19`
`18`		`- public object Resolve(CharacteristicObject obj, Characteristic characteristic)`
	`20`	`+ public object? Resolve(CharacteristicObject obj, Characteristic characteristic)`
`19`	`21`	`{`
`20`	`22`	`if (obj.HasValue(characteristic))`
`21`	`23`	`return characteristic[obj];`
`@@ -26,7 +28,7 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic)`
`26`	`28`	`throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");`
`27`	`29`	`}`
`28`	`30`
`29`		`- public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)`
	`31`	`+ public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)`
`30`	`32`	`{`
`31`	`33`	`if (obj.HasValue(characteristic))`
`32`	`34`	`return characteristic[obj];`
`@@ -37,7 +39,7 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic)`
`37`	`39`	`throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");`
`38`	`40`	`}`
`39`	`41`
`40`		`- public object Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)`
	`42`	`+ public object? Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)`
`41`	`43`	`{`
`42`	`44`	`if (obj.HasValue(characteristic))`
`43`	`45`	`return characteristic[obj];`
`@@ -48,7 +50,7 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic, o`
`48`	`50`	`return defaultValue;`
`49`	`51`	`}`
`50`	`52`
`51`		`- public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)`
	`53`	`+ public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)`
`52`	`54`	`{`
`53`	`55`	`if (obj.HasValue(characteristic))`
`54`	`56`	`return characteristic[obj];`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`using System.Diagnostics.CodeAnalysis;`
`2`	`2`
	`3`	`+#nullable enable`
	`4`	`+`
`3`	`5`	`namespace BenchmarkDotNet.Characteristics`
`4`	`6`	`{`
`5`	`7`	`/// <summary>`
`@@ -9,12 +11,12 @@ public interface IResolver`
`9`	`11`	`{`
`10`	`12`	`bool CanResolve(Characteristic characteristic);`
`11`	`13`
`12`		`- object Resolve(CharacteristicObject obj, Characteristic characteristic);`
	`14`	`+ object? Resolve(CharacteristicObject obj, Characteristic characteristic);`
`13`	`15`
`14`		`- T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic);`
	`16`	`+ T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic);`
`15`	`17`
`16`		`- object Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue);`
	`18`	`+ object? Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue);`
`17`	`19`
`18`		`- T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue);`
	`20`	`+ T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue);`
`19`	`21`	`}`
`20`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,21 +2,23 @@`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Diagnostics.CodeAnalysis;`
`4`	`4`
	`5`	`+#nullable enable`
	`6`	`+`
`5`	`7`	`namespace BenchmarkDotNet.Characteristics`
`6`	`8`	`{`
`7`	`9`	`public class Resolver : IResolver`
`8`	`10`	`{`
`9`		`- private readonly Dictionary<Characteristic, Func<CharacteristicObject, object>> resolvers = new Dictionary<Characteristic, Func<CharacteristicObject, object>>();`
	`11`	`+ private readonly Dictionary<Characteristic, Func<CharacteristicObject, object?>> resolvers = new Dictionary<Characteristic, Func<CharacteristicObject, object?>>();`
`10`	`12`
`11`		`- protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<T> resolver) =>`
	`13`	`+ protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<T?> resolver) =>`
`12`	`14`	`resolvers[characteristic] = obj => resolver();`
`13`	`15`
`14`		`- protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<CharacteristicObject, T> resolver) =>`
	`16`	`+ protected void Register<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(Characteristic<T> characteristic, Func<CharacteristicObject, T?> resolver) =>`
`15`	`17`	`resolvers[characteristic] = obj => resolver(obj);`
`16`	`18`
`17`	`19`	`public bool CanResolve(Characteristic characteristic) => resolvers.ContainsKey(characteristic);`
`18`	`20`
`19`		`- public object Resolve(CharacteristicObject obj, Characteristic characteristic)`
	`21`	`+ public object? Resolve(CharacteristicObject obj, Characteristic characteristic)`
`20`	`22`	`{`
`21`	`23`	`if (obj.HasValue(characteristic))`
`22`	`24`	`return characteristic[obj];`
`@@ -26,17 +28,17 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic)`
`26`	`28`	`throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");`
`27`	`29`	`}`
`28`	`30`
`29`		`- public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)`
	`31`	`+ public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic)`
`30`	`32`	`{`
`31`	`33`	`if (obj.HasValue(characteristic))`
`32`	`34`	`return characteristic[obj];`
`33`	`35`
`34`	`36`	`if (resolvers.TryGetValue(characteristic, out var resolver))`
`35`		`- return (T)resolver(obj);`
	`37`	`+ return (T?)resolver(obj);`
`36`	`38`	`throw new InvalidOperationException($"There is no default resolver for {characteristic.FullId}");`
`37`	`39`	`}`
`38`	`40`
`39`		`- public object Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)`
	`41`	`+ public object? Resolve(CharacteristicObject obj, Characteristic characteristic, object defaultValue)`
`40`	`42`	`{`
`41`	`43`	`if (obj.HasValue(characteristic))`
`42`	`44`	`return characteristic[obj];`
`@@ -47,13 +49,13 @@ public object Resolve(CharacteristicObject obj, Characteristic characteristic, o`
`47`	`49`	`return defaultValue;`
`48`	`50`	`}`
`49`	`51`
`50`		`- public T Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)`
	`52`	`+ public T? Resolve<[DynamicallyAccessedMembers(CharacteristicObject.CharacteristicMemberTypes)] T>(CharacteristicObject obj, Characteristic<T> characteristic, T defaultValue)`
`51`	`53`	`{`
`52`	`54`	`if (obj.HasValue(characteristic))`
`53`	`55`	`return characteristic[obj];`
`54`	`56`
`55`	`57`	`if (resolvers.TryGetValue(characteristic, out var resolver))`
`56`		`- return (T)resolver(obj);`
	`58`	`+ return (T?)resolver(obj);`
`57`	`59`
`58`	`60`	`return defaultValue;`
`59`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara`
`47`	`47`	`{`
`48`	`48`	`var runtime = benchmark.Job.ResolveValue(EnvironmentMode.RuntimeCharacteristic, EnvironmentResolver.Instance);`
`49`	`49`
`50`		`- if (runtime.RuntimeMoniker < RuntimeMoniker.NetCoreApp30)`
	`50`	`+ if (runtime != null && runtime.RuntimeMoniker < RuntimeMoniker.NetCoreApp30)`
`51`	`51`	`{`
`52`	`52`	`yield return new ValidationError(true, $"{nameof(ThreadingDiagnoser)} supports only .NET Core 3.0+", benchmark);`
`53`	`53`	`}`