这是一个很好的问题，我最近在将一个大型（错误缠身的）遗留代码库从.NET Framework迁移到.NET Core时也遇到了这个问题。
OP的更新非常有帮助，但是我想分享一个稍微简化的、性能更高的解决方案，它消除了对SwaggerGen.TypeExtensions.GetDefaultValue()的依赖，也没有泛型依赖;因此可以将其作为Converter全局应用：

private static readonly NullToDefaultConverter _jsonLegacyCompatibleNullValueConverter = new();

   . . .

var model = JsonConvert.DeserializeObject(content, modelType, _jsonLegacyCompatibleNullValueConverter);

当Json .NET反序列化时，通过object existingValue输入参数提供当前现有值或默认值，该参数将具有属性的默认值或属性初始值设定项设置的初始值。在这两种情况下，我们可能都希望保留该值，因此可以只返回它，从而提供与旧的.NET Framework Web API行为更兼容的行为（如观察员的帖子所述）。
还要注意，我们只需要处理那些 * 不能被分配 * null值的属性，因此可以在Type上进行更高性能的检查（改编自优雅的stack overflow answer here）。

/// <summary>
/// This is a Json Converter that restores legacy ASP.Net MVC compatible behavior for handling values that cannot be assigned Null.
/// Historically (before .NET Core) Json values of null would result in errors when setting them into values that cannot be assigned null,
///     however these errors treated as warnings and were skipped, leaving the original default values set on the Model. Now in 
///     Asp .NET Core, these failures result in Exceptions being thrown.
/// While previously the result was that these fields were simply left their default values; either the default of the Value type 
///     or the default set in the Property Initializer.
/// Therefore this Json Converter restores this behavior by assigning the Default value safely without any errors being thrown.
/// </summary>
public class NullToDefaultConverter : JsonConverter
{
    public static bool CanTypeBeAssignedNull(Type type)
        => !type.IsValueType || (Nullable.GetUnderlyingType(type) != null);

    //Only Handle Fields that would fail a Null assignment and requires resolving of a non-null existing/default value for the Type!
    public override bool CanConvert(Type objectType) => !CanTypeBeAssignedNull(objectType);

    public override object ReadJson(JsonReader reader, Type objectType, object existingOrDefaultValue, JsonSerializer serializer)
    {
        var token = JToken.Load(reader);
        return token.Type == JTokenType.Null ? existingOrDefaultValue : token.ToObject(objectType);
    }

    // Return false; we want normal Json.NET behavior when serializing...
    public override bool CanWrite => false;

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => throw new NotImplementedException();
}

为了进一步扩展如何在全局范围内恢复遗留兼容行为，我们实现了一个自定义的Input Formatter，如下所示：

public class JsonLegacyCompatibilityInputFormatter : TextInputFormatter
    {
        public bool EnableExceptions { get; set; }

        private static readonly NullToDefaultConverter _jsonLegacyCompatibleNullValueConverter = new();

        public JsonLegacyCompatibilityInputFormatter(bool enableExceptions = true)
        {
            EnableExceptions = enableExceptions;
            //Add Supported Media Types
            SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
            //Add Supported Encodings
            SupportedEncodings.Add(Encoding.UTF8);
            SupportedEncodings.Add(Encoding.Unicode);
        }

        public override async Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding effectiveEncoding)
        {
            var httpRequest = context.HttpContext.Request;
            var modelType = context.ModelType;
            try
            {
                using var streamReader = new StreamReader(httpRequest.Body, effectiveEncoding);
                var content = await streamReader.ReadToEndAsync().ConfigureAwait(false);

                //NOTE: There is a deviation between .NET Framework and Asp .NET Core handling of null values with properties that cannot be assigned a null value.
                //      Therefore To be compatible with Legacy Web API behavior we  provide the JsonLegacyCompatibleNullValueConverter to ensure
                //          that properties that cannot be assigned null from null Json values retain their original or default value without exceptions being thrown.
                var model = JsonConvert.DeserializeObject(content, modelType, _jsonLegacyCompatibleNullValueConverter);

                return await InputFormatterResult.SuccessAsync(model).ConfigureAwait(false);
            }
            catch (Exception exc)
            {
                var message = $"Error occurred during Model binding de-serialization of [{modelType.Name}].";
                serviceProvider.GetService<ILogger>()?.LogError(exc, message);

                #if DEBUG
                Debug.WriteLine(exc.ConvertExceptionToJson());
                #endif

                if (EnableExceptions)
                    throw new Exception(message, exc);
                else
                    return await InputFormatterResult.FailureAsync().ConfigureAwait(false);
            }
        }
    }

通过以下方式配置为供所有模型绑定使用：

// Configure MVC Services...
builder.Services
    .AddControllersWithViews(options =>
    {
        options.InputFormatters.Insert(0, new JsonLegacyCompatibilityInputFormatter());
    })

EDIT -优化版本现已在Nuget上共享：

自从最初分享这个解决方案以来，我意识到有一些性能影响和一些其他的兼容性问题，比如错误处理，需要解决。实作自订JsonBufferedHttpRequestReader和CharArrayPool，而非以不必要的配置序列化至字串。它还通过将所有错误推入ModelState并防止抛出这些异常来实现错误处理的传统兼容性。
此完整版本可在Nuget上获得，网址为：https://github.com/cajuncoding/AspNetCoreMigrationShims
并且可以像Newtonsoft一样通过以下方式轻松配置：

builder.Services
   .AddControllersWithViews(options => {})
   .AddNewtonsfotJson(options => {}) //Original Newtsonsoft Configuration
   .WithNewtonsoftJsonNetFrameworkCompatibility(); //Now updated and re-configured for better Legacy Compatibility

仅使属性可为空

public class OrderEffortDto
{
    .........
    public bool? Cwe { get; set; }
    public decimal? EffortInHours { get; set; }
    public decimal? Hours25InHours { get; set; }
    public decimal? Hours50InHours { get; set; }
    public decimal? Hours100InHours { get; set; }
    public decimal? Hours150InHours { get; set; }
   
}

也可以添加构造函数而不是使其可为null。只能在构造函数中包含在反序列化过程中需要更改的属性

[Newtonsoft.Json.JsonConstructor]
     public OrderEffortDto(
     bool? cwe ,
     decimal? effortInHours ,
     decimal? hours25InHours ,
     decimal? hours50InHours ,
     decimal? hours100InHours ,
     decimal? hours150InHours )
    {
        Cwe = cwe==null?false: (bool) Cwe;
        EffortInHours = effortInHours==null? 0: (decimal) effortInHours;
       .... and so on
    }