How to convert custom object to JSON with null value avoidance using C# and RestSharp?

Step 1:

First of all we need to create one class.

 [JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
    public class UpdateUserDetailsRequest
    {
        /// <summary>
        /// The operation to perform: Add, Remove, Replace, Copy, Move, Test
        /// </summary>
        [Required(ErrorMessage = "Operation to perform is required")]
        [RestSharp.Serializers.SerializeAs(Name = "op")]
        [JsonProperty("op")]
        public string OperationToPerform { get; set; }
        [Required(ErrorMessage = "Path is required")]
        [JsonProperty("path")]
        [RestSharp.Serializers.SerializeAs(Name = "path")]
        public string Path { get; set; }
        [RestSharp.Serializers.SerializeAs(Name = "from")]
        [JsonProperty("from")]
        public string From { get; set; }
        [RestSharp.Serializers.SerializeAs(Name = "value")]
        [JsonProperty("value")]
        public string Value { get; set; }
    }

This is my class to make request through RestSharp.

————————–———YOU CAN AVOID THIS SECTION 1———————————–

To avoid null values for whole class then we have to write:

[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
public class YourClass
{
.....
.....
}

OR

To avoid null values for specific property then we have to write:

public class YourClass
{
[JsonProperty("property_name", NullValueHandling=NullValueHandling.Ignore)]
public string Property1 {get; set;}
public string Property2 {get; set;}
}

Here property_name will change as per your JSON requirement. For example assume we have to use our property name insted of JSON property name. Assume we have following have to make following JSON string:

{
firstname: "Nileksh",
lastname: "Dhimer",
city: "Dhamdod"
}

so we will make class like:

public class YourClassName
{
[JsonProperty("firstname", NullValueHandling=NullValueHandling.Ignore)] //This will convert property name during serialization
public string FirstName {get;set;} //This will convert property name during de-serialization

[JsonProperty("lastname", NullValueHandling=NullValueHandling.Ignore)]
public string LastName {get;set;}

[JsonProperty("city", NullValueHandling=NullValueHandling.Ignore)]
public string City {get;set;}
}

So JsonProperty will allow us to make exact JSON property name which we have to pass during API request using RestSharp.

————————–———YOU CAN AVOID THIS SECTION 1———————————–

Step 2:

Then we have to create custom serialization class.

 /// <summary>
    /// Default JSON serializer for request bodies
    /// Doesn't currently use the SerializeAs attribute, defers to Newtonsoft's attributes
    /// </summary>
    public class RestSharpJsonNetSerializer : ISerializer
    {
        private readonly Newtonsoft.Json.JsonSerializer _serializer;

        /// <summary>
        /// Default serializer
        /// </summary>
        public RestSharpJsonNetSerializer()
        {
            ContentType = "application/json";
            _serializer = new Newtonsoft.Json.JsonSerializer
            {
                MissingMemberHandling = MissingMemberHandling.Ignore,
                NullValueHandling = NullValueHandling.Include,
                DefaultValueHandling = DefaultValueHandling.Include
            };
        }

        /// <summary>
        /// Default serializer with overload for allowing custom Json.NET settings
        /// </summary>
        public RestSharpJsonNetSerializer(Newtonsoft.Json.JsonSerializer serializer)
        {
            ContentType = "application/json";
            _serializer = serializer;
        }

        /// <summary>
        /// Serialize the object as JSON
        /// </summary>
        /// <param name="obj">Object to serialize
        /// <returns>JSON as String</returns>
        public string Serialize(object obj)
        {
            using (var stringWriter = new StringWriter())
            {
                using (var jsonTextWriter = new JsonTextWriter(stringWriter))
                {
                    jsonTextWriter.Formatting = Formatting.Indented;
                    jsonTextWriter.QuoteChar = '"';

                    _serializer.Serialize(jsonTextWriter, obj);

                    var result = stringWriter.ToString();
                    return result;
                }
            }
        }

        /// <summary>
        /// Unused for JSON Serialization
        /// </summary>
        public string DateFormat { get; set; }
        /// <summary>
        /// Unused for JSON Serialization
        /// </summary>
        public string RootElement { get; set; }
        /// <summary>
        /// Unused for JSON Serialization
        /// </summary>
        public string Namespace { get; set; }
        /// <summary>
        /// Content type for serialized content
        /// </summary>
        public string ContentType { get; set; }
    }

Step 3:

Now we have to use this during RestSharp request.

var client = new RestSharp.RestClient("YOUR REQUEST URL");
var request = new RestSharp.RestRequest(RestSharp.Method.PATCH);
request.RequestFormat = RestSharp.DataFormat.Json;
request.JsonSerializer = new RestSharpJsonNetSerializer();
request.AddHeader("Content-Type", "application/json-patch+json");
request.AddJsonBody(req);
var response = client.Execute(request);

Here req is an object of your class so you have to create object and then fill the values in object and then we pass it to AddJsonBody. That’s it.