Using System.Text.Json to ignore default values for bool data type, only

Is there a way at a global level to ignore all and only bools when returning false with System.Text.Json?

I know there's this global condition, but I still need other default values to return.

JsonSerializerOptions options = new()
           {
                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault
            };

Ideally would not like to add the following to all propeties individually..
[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]

You can't use a custom JsonConverter for all types, because then you'll have to reinvent the wheel to serialize whole thing. You also can't use a JsonConverter<bool> (or <bool?>), because you have to write a value in its Write() method.

So register a DefaultJsonTypeInfoResolver with a custom Modifiers action that only serializes bools when their value equals true:

JsonSerializerOptions options = new()
{
    TypeInfoResolver = new DefaultJsonTypeInfoResolver
    {
        Modifiers =
        {
            jsonTypeInfo =>
            {
                foreach (var p in jsonTypeInfo.Properties)
                {
                    if (p.PropertyType == typeof(bool) || p.PropertyType == typeof(bool?))
                    {
                        p.ShouldSerialize = (containingObject, propertyValue) =>
                        {
                            return propertyValue as bool? == true;
                        };
                    }
                }
            }
        }
    }
};

From MS Learn: Customize a JSON contract. Works since .NET 7.

In .NET 7 and later you can use a typeInfo modifier to customize your type's contract to skip serialization of bool properties whose value is false.

First define the following modifier:

public static partial class JsonExtensions
{
	static Func<object, object?, bool> ShouldSerializeBool { get; } = static (obj, value) => (value is bool b ? b : true);

	public static Action<JsonTypeInfo> IgnoreFalseBoolProperties { get; } = static typeInfo => 
		{
			if (typeInfo.Kind != JsonTypeInfoKind.Object)
				return;
			foreach (var property in typeInfo.Properties)
				if (property.PropertyType == typeof(bool))
				{
					if (property.ShouldSerialize is {} shouldSerialize)
						property.ShouldSerialize = (o, v) => ShouldSerializeBool(o, v) && shouldSerialize(o, v);
					else
						property.ShouldSerialize = ShouldSerializeBool;
				}
		};
}

And now if your model looks like, e.g.:

public record Model(bool BoolValue, int IntValue, bool? NullableBoolValue);

When you serialize a model with default values using the modifier:

var options = new JsonSerializerOptions
{
	TypeInfoResolver = new DefaultJsonTypeInfoResolver
	{
		Modifiers = { JsonExtensions.IgnoreFalseBoolProperties },
	},
	// Others as required
};
var json = JsonSerializer.Serialize(new Model(default, default, default), options);

The false bool property will be skipped:

{"IntValue":0,"NullableBoolValue":null}

But when serialized with a true bool value:

var json2 = JsonSerializer.Serialize(new Model(true, default, default), options);

You will get:

{"BoolValue":true,"IntValue":0,"NullableBoolValue":null}

Demo fiddle here.