Serializing a protected property in a generic class with Json.NET

Question

I am trying to serialize a class that is made up of many variables all inheriting from IMyDataType.

public abstract class IMyDataType<T>
{
    protected virtual T Data { get; set; }
    public abstract String ToString(String args = null);
    public abstract Boolean SetValue(T newValue);
    public abstract Boolean CheckValue(T newValue);
    public abstract T GetValue();
}

For instance I might have a class MyInteger

public class MyInteger : IMyDataType<int>
{
    public int Min { get; protected set; }
    public int Max { get; protected set; }
    protected override int Data { get; set; }

    public MyInteger(int value)
    {
        Min = int.MinValue;
        Max = int.MaxValue;
        if (!SetValue(value))
            Data = 0;
    }

    public MyInteger(int min, int value, int max)
    {
        Min = min;
        Max = max;
        if (!SetValue(value))
            Data = 0;
    }

    public override Boolean SetValue(int newVal)
    {
        if (newVal >= Min && newVal <= Max)
        {
            Data = newVal;
            return true;
        }
        return false;
    }

    public override Boolean CheckValue(int newVal)
    {
        return (newVal >= Min && newVal <= Max);
    }

    public override int GetValue() { return Data; }
    public override String ToString(String args = null) { return Data.ToString(args); }
}

Whenever I try to serialize a subclass of IMyDataType the variable T Data is never serialized, though Min and Max are. What do I need to do to get T Data to be serialized?

EDIT: Based on DotNetom's answer I changed the access modifier of T Data to public, which did allow it to be serialized. Though, there are reasons for it being protected. Is there any other means by which I could serialize it while keeping its access modifier intact?

Answer 1

You could simply create an alternate private property getter for Data and mark it with a [JsonProperty] attribute. This will allow Json.Net to "see" it and serialize it without needing to alter the access modifier of the original property.

public abstract class IMyDataType<T>
{
    protected virtual T Data { get; set; }
    ...

    [JsonProperty("Value")]
    private T AlternateData
    {
        get { return Data; }
    }
}

Fiddle: https://dotnetfiddle.net/0JMZzX

(Note: In theory, you could just mark the protected Data property itself with the [JsonProperty] attribute instead of creating an alternate property getter. However, this only seems to work if the base property is not overridden in the subclass. Once you override it, the attribute no longer works for some reason -- even if you move the attribute to the subclass or place it in both the base class and subclass. I'm not sure whether this is a bug in Json.Net or intentional. Using an alternate getter always seems to work though.)