How to serialise a Exception using JsonSerializer.Serialize in C#

Serialising Exception Data to JSON in C#

Introduction:

In software development, handling exceptions is a crucial part of writing robust applications. When exceptions occur, developers often need to log and report them for debugging and monitoring purposes. One way to achieve this is by serialising exception data to JSON, allowing you to easily store and analyse error information. In this blog post, we will explore how to serialise exception data to JSON using the JsonSerializer.Serialize method in C#. We'll use a custom class, ExceptionData, to encapsulate exception information.

Creating the ExceptionData Class:

To get started, we need to create a custom class called ExceptionData. This class will capture various properties of an exception, such as message, source, stack trace, type name, and optionally inner exceptions. Here's the ExceptionData class:

public class ExceptionData
{
    public ExceptionData(Exception exception, bool includeInnerException = true, bool includeStackTrace = true)
    {
        if (exception is null)
        {
            throw new ArgumentNullException(nameof(exception));
        }

        Message = exception.Message;
        Source = exception.Source;
        StackTrace = includeStackTrace ? exception.StackTrace : null;
        TypeName = exception.GetType().FullName;

        if (includeInnerException && exception.InnerException != null)
        {
            InnerException = new ExceptionData(exception.InnerException);
        }
    }

    public string Message { get; set; }
    public string Source { get; set; }
    public string StackTrace { get; set; }
    public string TypeName { get; set; }
    public ExceptionData InnerException { get; set; }
}

This ExceptionData class is responsible for capturing exception information and providing options to include inner exceptions and stack traces.

Serialising Exception Data to JSON:

Now that we have our ExceptionData class, let's see how to use it to serialise exception data to JSON using the JsonSerializer.Serialize method. Here's an example:

using System;
using System.Text.Json;

public class Program
{
    public static void Main()
    {
        try
        {
            // Simulate an exception
            throw new InvalidOperationException("This is a test exception.");
        }
        catch (Exception ex)
        {
            // Create an instance of ExceptionData
            var exceptionData = new ExceptionData(ex);

            // Serialise the exception data to JSON
            string json = JsonSerializer.Serialize(exceptionData, new JsonSerializerOptions
            {
                WriteIndented = true, // Optional: Format the JSON for better readability

                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull //Optional: Do not write null values to the serialised JSON
            });

            Console.WriteLine(json);
        }
    }
}

In this example, we catch an exception, create an instance of ExceptionData, and then use JsonSerializer.Serialize to convert it to JSON. The JsonSerializerOptions allow you to control the serialisation behaviour, and in this case, we enable the WriteIndented option to format the JSON for better readability.

Conclusion:

Serialising exception data to JSON is a valuable practice for error reporting and debugging in your C# applications. By using the ExceptionData class and the JsonSerializer.Serialize method, you can efficiently capture and store exception information in a structured format. This data can be logged, transmitted, and analysed, making it easier to diagnose issues and maintain the reliability of your software.