JSON.NET Unable to deserialize ulong flag type enum

You have encountered a known bug in Json.NET with ulong-type enumerations: Failure to deserialize ulong enum #2301

Serialization of ulong enum values works fine,
but deserialization fails on large values.

As a workaround, if you are not using Json.NET's StringEnumConverter, you can add the following converter that correctly handles very large values for ulong enums:

public class FixedUlongEnumConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        var enumType = Nullable.GetUnderlyingType(objectType) ?? objectType;
        if (!enumType.IsEnum)
            return false;
        return Enum.GetUnderlyingType(enumType) == typeof(ulong);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var nullableUnderlying = Nullable.GetUnderlyingType(objectType);
        var enumType = nullableUnderlying ?? objectType;
        var isNullable = nullableUnderlying != null;
        switch (reader.MoveToContentAndAssert().TokenType)
        {
            case JsonToken.Null:
                if (!isNullable)
                    throw new JsonSerializationException(string.Format("Null value for {0}", objectType));
                return null;

            case JsonToken.Integer:
                if (reader.ValueType == typeof(System.Numerics.BigInteger))
                {
                    var bigInteger = (System.Numerics.BigInteger)reader.Value;
                    if (bigInteger >= ulong.MinValue && bigInteger <= ulong.MaxValue)
                    {
                        return Enum.ToObject(enumType, checked((ulong)bigInteger));
                    }
                    else
                    {
                        throw new JsonSerializationException(string.Format("Value {0} is too large for enum {1}", bigInteger, enumType));
                    }
                }
                else
                {
                    return Enum.ToObject(enumType, reader.Value);
                }

            default:
                throw new JsonSerializationException(string.Format("Unexpected token {0}", reader.TokenType));          
        }
    }

    public override bool CanWrite { get { return false; } }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

public static partial class JsonExtensions
{
    public static JsonReader MoveToContentAndAssert(this JsonReader reader)
    {
        if (reader == null)
            throw new ArgumentNullException();
        if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.
            reader.ReadAndAssert();
        while (reader.TokenType == JsonToken.Comment) // Skip past comments.
            reader.ReadAndAssert();
        return reader;
    }

    public static JsonReader ReadAndAssert(this JsonReader reader)
    {
        if (reader == null)
            throw new ArgumentNullException();
        if (!reader.Read())
            throw new JsonReaderException("Unexpected end of JSON stream.");
        return reader;
    }
}

Demo fiddle #1 here.

And if you are using Json.NET's StringEnumConverter but might sometimes get numeric values for enums anyway, replace it with this fixed version:

public class FixedUlongStringEnumConverter : StringEnumConverter
{
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.MoveToContentAndAssert().TokenType == JsonToken.Integer && reader.ValueType == typeof(System.Numerics.BigInteger))
        {
            // Todo: throw an exception if !this.AllowIntegerValues
            // https://www.newtonsoft.com/json/help/html/P_Newtonsoft_Json_Converters_StringEnumConverter_AllowIntegerValues.htm
            var enumType = Nullable.GetUnderlyingType(objectType) ?? objectType;
            if (Enum.GetUnderlyingType(enumType) == typeof(ulong))
            {
                var bigInteger = (System.Numerics.BigInteger)reader.Value;
                if (bigInteger >= ulong.MinValue && bigInteger <= ulong.MaxValue)
                {
                    return Enum.ToObject(enumType, checked((ulong)bigInteger));
                }
            }
        }
        return base.ReadJson(reader, objectType, existingValue, serializer);
    }
}

public static partial class JsonExtensions
{
    public static JsonReader MoveToContentAndAssert(this JsonReader reader)
    {
        if (reader == null)
            throw new ArgumentNullException();
        if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.
            reader.ReadAndAssert();
        while (reader.TokenType == JsonToken.Comment) // Skip past comments.
            reader.ReadAndAssert();
        return reader;
    }

    public static JsonReader ReadAndAssert(this JsonReader reader)
    {
        if (reader == null)
            throw new ArgumentNullException();
        if (!reader.Read())
            throw new JsonReaderException("Unexpected end of JSON stream.");
        return reader;
    }
}

Now, you have an additional requirement to serialize [Flags] enums, and only [Flags] enums, as integers. You can do this by further subclassing the above converter as follows:

public class ForceNumericFlagEnumConverter : FixedUlongStringEnumConverter
{
    static bool HasFlagsAttribute(Type objectType) 
    { 
        return Attribute.IsDefined(Nullable.GetUnderlyingType(objectType) ?? objectType, typeof(System.FlagsAttribute));
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var enumType = value.GetType();
        if (HasFlagsAttribute(enumType))
        {
            var underlyingType = Enum.GetUnderlyingType(enumType);
            var underlyingValue = Convert.ChangeType(value, underlyingType);
            writer.WriteValue(underlyingValue);
        }
        else
        {
            base.WriteJson(writer, value, serializer);
        }
    }   
}

The workaround requires support for BigInteger which was introduced in .NET Framework 4.0.

Demo fiddle #2 here.

Change ulong to uint :

public enum UserCan : uint
{
    DoNothing = 0,
    ChangeConf =               1 << 0,
    MonitorOthers =              1 << 1,
    ForceOther =                1 << 2,
    EditRemoveOthers =           1 << 3,

    DoEverything = unchecked((uint)~0),
}

Working fiddle:

https://dotnetfiddle.net/DyQ2R7