We are forcing ourselves to use System.Text.Json where we can, not sure we have noticed major performance increases. However, there have been several compatibility issues, where the defaults provided by Newtonsoft were not supported by System.Text.Json at the time.

Once you work through things and increment your api versions to different patterns that support the System.Text.Json use cases everything works great. If I recall the guy who made Newtonsoft started working at MS, not sure if on the json codebase though.

Advantages of Newtonsoft.Json (A.k.a Json.NET)

- Mature

- Lots of configurability

- Wide range support for use cases

Disadvantages of Newtonsoft.Json

- This applies to older packages, but several MS provided packages could never make up their mind about which newtonsoft.Json version to use, and would lock versions making it incompatible with other MS packages.

Advantages of System.Text.Json

- Supposedly new and improved (performance)

- Built into ASP.NET now

- Plug and play in most cases where Newtonsoft was used previously

Disadvantages of System.Text.Json

- Support for complex cases can be difficult to find

- This is big for us, Polymorphic (De)Serialization

- Reference loop handling is weird, newtonsoft was more graceful

As far as I know, there is no build-in way to specific the Jsonconvert for specific controller.

If you want to modify the generated json result jsonconvert, I suggest you could try to use this way.

I suggest you could try to use actionfilter to achieve your requirement.

By using actionfilter, you could modift the input formatter to use other jsonconvert to convert the data.

public class CaseActionAttribute : ActionFilterAttribute
{
    public override void OnActionExecuted(ActionExecutedContext ctx)
    {
        if (ctx.Result is ObjectResult objectResult)
        {
            objectResult.Formatters.Add(new SystemTextJsonOutputFormatter(new JsonSerializerOptions
            {
                IgnoreNullValues = true
            }));
        }
    }
}

Usage:

    [HttpPost]
    [CaseAction]
    public ActionResult Index([FromForm]Member member) {
        if (ModelState.IsValid)
        {
            RedirectToAction("Index");
        }

        return Ok();
    }

If you want to set the convert for the model binder, the only way is create a cusotmer modle binder and modify the json formatter according to each model type. There is no way to achieve it according to asp.net core has modified the iresoucefilter to not support change is formater.

You are asking a few questions here:

1. I am not able to find any equivalent for JObject.Parse(json);

   In .NET 6 and later the closest equivalent to LINQ to JSON is the System.Text.Json.Nodes API. This API provides a mutable JSON document object model you can use to parse arbitrary JSON:

   • JToken corresponds to JsonNode, so JToken.Parse(json) becomes JsonNode.Parse(json) or JsonSerializer.Deserialize<JsonNode>(json).
   • JObject corresponds to JsonObject so JObject.Parse(json) becomes JsonNode.Parse(json).AsObject() or JsonSerializer.Deserialize<JsonObject>(json)

   For usage details see this answer by haldo to Equivalent of JObject in System.Text.Json.

   Before .NET 6 you can use JsonDocument to parse and examine any JSON, starting with its RootElement. The root element is of type JsonElement which represents any JSON value (primitive or not) and corresponds to Newtonsoft's JToken.

   But do take note of this documentation remark:

   This class utilizes resources from pooled memory to minimize the impact of the garbage collector (GC) in high-usage scenarios. Failure to properly dispose this object will result in the memory not being returned to the pool, which will increase GC impact across various parts of the framework.

   When you need to use a JsonElement outside the lifetime of its document, you must clone it:

   Gets a JsonElement that can be safely stored beyond the lifetime of the original JsonDocument.

   Also note that JsonDocument is currently read-only and does not provide an API for creating or modifying JSON. There is an open issue Issue #39922: Writable Json DOM tracking this.

   An example of use is as follows:

   //https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#using-declarations 
   using var doc = JsonDocument.Parse(json);
   
   //Print the property names.
   var names = doc.RootElement.EnumerateObject().Select(p => p.Name);
   Console.WriteLine("Property names: {0}", string.Join(",", names)); // Property names: status,message,Log_id,Log_status,FailureReason
   
   //Re-serialize with indentation.
   using var ms = new MemoryStream();
   using (var writer = new Utf8JsonWriter(ms, new JsonWriterOptions { Indented = true }))
   {
       doc.WriteTo(writer);
   }
   var json2 = Encoding.UTF8.GetString(ms.GetBuffer(), 0, checked((int)ms.Length));
   
   Console.WriteLine(json2);
   

2. Also what will be the attribute JsonProperty equivalent?

   Attributes that can control JsonSerializer are placed in the System.Text.Json.Serialization namespace and inherit from an abstract base class JsonAttribute. Unlike Newtonsoft's JsonProperty, there is no omnibus attribute that can control all aspects of property serialization. Instead there are specific attributes to control specific aspects.

   As of .NET Core 3 these include:

   • [JsonPropertyNameAttribute(string)]:

     Specifies the property name that is present in the JSON when serializing and deserializing. This overrides any naming policy specified by JsonNamingPolicy.

     This is attribute you want to use to control the serialized names of your ResponseJson class:

     public class ResponseJson
     {
         [JsonPropertyName("status")]
         public bool Status { get; set; }
         [JsonPropertyName("message")]
         public string Message { get; set; }
         [JsonPropertyName("Log_id")]
         public string LogId { get; set; }
         [JsonPropertyName("Log_status")]
         public string LogStatus { get; set; }
     
         public string FailureReason { get; set; }
     }
     

   • [JsonConverterAttribute(Type)]:

     When placed on a type, the specified converter will be used unless a compatible converter is added to the JsonSerializerOptions.Converters collection or there is another JsonConverterAttribute on a property of the same type.

     Note that the documented priority of converters -- Attribute on property, then the Converters collection in options, then the Attribute on type -- differs from the documented order for Newtonsoft converters, which is the JsonConverter defined by attribute on a member, then the JsonConverter defined by an attribute on a class, and finally any converters passed to the JsonSerializer.

   • [JsonExtensionDataAttribute] - corresponds to Newtonsoft's [JsonExtensionData].

   • [JsonIgnoreAttribute] - corresponds to Newtonsoft's [JsonIgnore].

3. When writing JSON via Utf8JsonWriter, indentation can be controlled by setting JsonWriterOptions.Indented to true or false.

   When serializing to JSON via JsonSerializer.Serialize or JsonNode.ToJsonString(), indentation can be controlled by setting JsonSerializerOptions.WriteIndented to true or false.

Demo fiddle here showing serialization with JsonSerializer and parsing with JsonDocument.