public static void ReThrowWithPath(ref ReadStack state, JsonReaderException ex)
{
Debug.Assert(ex.Path == null);
string path = state.JsonPath();
string message = ex.Message;
// Insert the "Path" portion before "LineNumber" and "BytePositionInLine".
#if BUILDING_INBOX_LIBRARY
int iPos = message.AsSpan().LastIndexOf(" LineNumber: ");
#else
int iPos = message.LastIndexOf(" LineNumber: ", StringComparison.InvariantCulture);
#endif
if (iPos >= 0)
{
message = $"{message.Substring(0, iPos)} Path: {path} |{message.Substring(iPos)}";
}
else
{
message += $" Path: {path}.";
}
throw new JsonException(message, path, ex.LineNumber, ex.BytePositionInLine, ex);
}
protected override void OnReadEnumerable(JsonTokenType tokenType, ref ReadStack state, ref Utf8JsonReader reader)
{
if (Converter == null)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath());
}
if (state.Current.KeyName == null && (state.Current.IsProcessingDictionary || state.Current.IsProcessingIDictionaryConstructible))
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath());
return;
}
// We need an initialized array in order to store the values.
if (state.Current.IsProcessingEnumerable && state.Current.TempEnumerableValues == null && state.Current.ReturnValue == null)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath());
return;
}
TConverter value = Converter.Read(ref reader, RuntimePropertyType, Options);
JsonSerializer.ApplyValueToEnumerable(ref value, ref state, ref reader);
}
protected override void OnRead(JsonTokenType tokenType, ref ReadStack state, ref Utf8JsonReader reader)
{
if (Converter == null)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath());
}
TConverter value = Converter.Read(ref reader, RuntimePropertyType, Options);
if (state.Current.ReturnValue == null)
{
state.Current.ReturnValue = value;
}
else
{
Set(state.Current.ReturnValue, value);
}
}
private void VerifyRead(JsonTokenType tokenType, int depth, long bytesConsumed, ref ReadStack state, ref Utf8JsonReader reader)
{
switch (tokenType)
{
case JsonTokenType.StartArray:
if (reader.TokenType != JsonTokenType.EndArray)
{
ThrowHelper.ThrowJsonException_SerializationConverterRead(reader, state.JsonPath(), ConverterBase.ToString());
}
else if (depth != reader.CurrentDepth)
{
ThrowHelper.ThrowJsonException_SerializationConverterRead(reader, state.JsonPath(), ConverterBase.ToString());
}
// Should not be possible to have not read anything.
Debug.Assert(bytesConsumed < reader.BytesConsumed);
break;
case JsonTokenType.StartObject:
if (reader.TokenType != JsonTokenType.EndObject)
{
ThrowHelper.ThrowJsonException_SerializationConverterRead(reader, state.JsonPath(), ConverterBase.ToString());
}
else if (depth != reader.CurrentDepth)
{
ThrowHelper.ThrowJsonException_SerializationConverterRead(reader, state.JsonPath(), ConverterBase.ToString());
}
// Should not be possible to have not read anything.
Debug.Assert(bytesConsumed < reader.BytesConsumed);
break;
default:
// Reading a single property value.
if (reader.BytesConsumed != bytesConsumed)
{
ThrowHelper.ThrowJsonException_SerializationConverterRead(reader, state.JsonPath(), ConverterBase.ToString());
}
// Should not be possible to change token type.
Debug.Assert(reader.TokenType == tokenType);
break;
}
}
// If this method is changed, also change ApplyValueToEnumerable.
internal static void ApplyObjectToEnumerable(
object value,
ref ReadStack state,
ref Utf8JsonReader reader,
bool setPropertyDirectly = false)
{
Debug.Assert(!state.Current.SkipProperty);
if (state.Current.IsEnumerable)
{
if (state.Current.TempEnumerableValues != null)
{
state.Current.TempEnumerableValues.Add(value);
}
else
{
if (!(state.Current.ReturnValue is IList list))
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(value.GetType(), reader, state.JsonPath());
return;
}
list.Add(value);
}
}
else if (!setPropertyDirectly && state.Current.IsEnumerableProperty)
{
Debug.Assert(state.Current.JsonPropertyInfo != null);
Debug.Assert(state.Current.ReturnValue != null);
if (state.Current.TempEnumerableValues != null)
{
state.Current.TempEnumerableValues.Add(value);
}
else
{
IList list = (IList)state.Current.JsonPropertyInfo.GetValueAsObject(state.Current.ReturnValue);
if (list == null ||
// ImmutableArray<T> is a struct, so default value won't be null.
state.Current.JsonPropertyInfo.RuntimePropertyType.FullName.StartsWith(DefaultImmutableEnumerableConverter.ImmutableArrayGenericTypeName))
{
state.Current.JsonPropertyInfo.SetValueAsObject(state.Current.ReturnValue, value);
}
else
{
list.Add(value);
}
}
}
else if (state.Current.IsDictionary || (state.Current.IsDictionaryProperty && !setPropertyDirectly))
{
Debug.Assert(state.Current.ReturnValue != null);
IDictionary dictionary = (IDictionary)state.Current.JsonPropertyInfo.GetValueAsObject(state.Current.ReturnValue);
string key = state.Current.KeyName;
Debug.Assert(!string.IsNullOrEmpty(key));
dictionary[key] = value;
}
else if (state.Current.IsIDictionaryConstructible ||
(state.Current.IsIDictionaryConstructibleProperty && !setPropertyDirectly))
{
Debug.Assert(state.Current.TempDictionaryValues != null);
IDictionary dictionary = (IDictionary)state.Current.TempDictionaryValues;
string key = state.Current.KeyName;
Debug.Assert(!string.IsNullOrEmpty(key));
dictionary[key] = value;
}
else
{
Debug.Assert(state.Current.JsonPropertyInfo != null);
state.Current.JsonPropertyInfo.SetValueAsObject(state.Current.ReturnValue, value);
}
}
private static void HandleStartArray(
JsonSerializerOptions options,
ref Utf8JsonReader reader,
ref ReadStack state)
{
if (state.Current.SkipProperty)
{
// The array is not being applied to the object.
state.Push();
state.Current.Drain = true;
return;
}
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (jsonPropertyInfo == null)
{
jsonPropertyInfo = state.Current.JsonClassInfo.CreateRootObject(options);
}
else if (state.Current.JsonClassInfo.ClassType == ClassType.Unknown)
{
jsonPropertyInfo = state.Current.JsonClassInfo.CreatePolymorphicProperty(jsonPropertyInfo, typeof(object), options);
}
// Verify that we have a valid enumerable.
Type arrayType = jsonPropertyInfo.RuntimePropertyType;
if (!typeof(IEnumerable).IsAssignableFrom(arrayType))
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(arrayType, reader, state.JsonPath());
}
Debug.Assert(state.Current.IsProcessingEnumerableOrDictionary);
if (state.Current.CollectionPropertyInitialized)
{
// A nested json array so push a new stack frame.
Type elementType = jsonPropertyInfo.ElementClassInfo.Type;
state.Push();
state.Current.Initialize(elementType, options);
}
state.Current.CollectionPropertyInitialized = true;
if (state.Current.JsonClassInfo.ClassType == ClassType.Value)
{
// Custom converter code path.
state.Current.JsonPropertyInfo.Read(JsonTokenType.StartObject, ref state, ref reader);
}
else
{
// Set or replace the existing enumerable value.
object value = ReadStackFrame.CreateEnumerableValue(ref reader, ref state);
// If value is not null, then we don't have a converter so apply the value.
if (value != null)
{
if (state.Current.ReturnValue != null)
{
state.Current.JsonPropertyInfo.SetValueAsObject(state.Current.ReturnValue, value);
}
else
{
// Primitive arrays being returned without object
state.Current.SetReturnValue(value);
}
}
}
}
// Creates an IEnumerable<TRuntimePropertyType> and populates it with the items in the
// sourceList argument then uses the delegateKey argument to identify the appropriate cached
// CreateRange<TRuntimePropertyType> method to create and return the desired immutable collection type.
public override IDictionary CreateImmutableDictionaryInstance(ref ReadStack state, Type collectionType, string delegateKey, IDictionary sourceDictionary, JsonSerializerOptions options)
{
IDictionary collection = null;
if (!options.TryGetCreateRangeDelegate(delegateKey, out ImmutableCollectionCreator creator) ||
!creator.CreateImmutableDictionary(sourceDictionary, out collection))
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(collectionType, state.JsonPath());
}
return(collection);
}
protected override void OnReadEnumerable(JsonTokenType tokenType, ref ReadStack state, ref Utf8JsonReader reader)
{
if (Converter == null)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath());
}
TProperty value = Converter.Read(ref reader, s_underlyingType, Options);
TProperty?nullableValue = new TProperty?(value);
JsonSerializer.ApplyValueToEnumerable(ref nullableValue, ref state, ref reader);
}
private static void HandleStartDictionary(JsonSerializerOptions options, ref Utf8JsonReader reader, ref ReadStack state)
{
Debug.Assert(!state.Current.IsProcessingEnumerable);
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (jsonPropertyInfo == null)
{
jsonPropertyInfo = state.Current.JsonClassInfo.CreateRootObject(options);
}
Debug.Assert(jsonPropertyInfo != null);
// A nested object or dictionary so push new frame.
if (state.Current.CollectionPropertyInitialized)
{
state.Push();
state.Current.JsonClassInfo = jsonPropertyInfo.ElementClassInfo;
state.Current.InitializeJsonPropertyInfo();
state.Current.CollectionPropertyInitialized = true;
ClassType classType = state.Current.JsonClassInfo.ClassType;
if (classType == ClassType.Value &&
jsonPropertyInfo.ElementClassInfo.Type != typeof(object) &&
jsonPropertyInfo.ElementClassInfo.Type != typeof(JsonElement))
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(state.Current.JsonClassInfo.Type, reader, state.JsonPath());
}
JsonClassInfo classInfo = state.Current.JsonClassInfo;
if (state.Current.IsProcessingIDictionaryConstructible)
{
state.Current.TempDictionaryValues = (IDictionary)classInfo.CreateConcreteDictionary();
}
else
{
if (classInfo.CreateObject == null)
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(classInfo.Type, reader, state.JsonPath());
return;
}
state.Current.ReturnValue = classInfo.CreateObject();
}
return;
}
state.Current.CollectionPropertyInitialized = true;
if (state.Current.IsProcessingIDictionaryConstructible)
{
JsonClassInfo dictionaryClassInfo;
if (jsonPropertyInfo.DeclaredPropertyType == jsonPropertyInfo.ImplementedPropertyType)
{
dictionaryClassInfo = options.GetOrAddClass(jsonPropertyInfo.RuntimePropertyType);
}
else
{
dictionaryClassInfo = options.GetOrAddClass(jsonPropertyInfo.DeclaredPropertyType);
}
state.Current.TempDictionaryValues = (IDictionary)dictionaryClassInfo.CreateConcreteDictionary();
}
else
{
// Create the dictionary.
JsonClassInfo dictionaryClassInfo = jsonPropertyInfo.RuntimeClassInfo;
IDictionary value = (IDictionary)dictionaryClassInfo.CreateObject();
if (value != null)
{
if (state.Current.ReturnValue != null)
{
state.Current.JsonPropertyInfo.SetValueAsObject(state.Current.ReturnValue, value);
}
else
{
// A dictionary is being returned directly, or a nested dictionary.
state.Current.SetReturnValue(value);
}
}
}
}
public static object CreateEnumerableValue(ref Utf8JsonReader reader, ref ReadStack state)
{
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
// If the property has an EnumerableConverter, then we use tempEnumerableValues.
if (jsonPropertyInfo.EnumerableConverter != null)
{
IList converterList;
if (jsonPropertyInfo.ElementClassInfo.ClassType == ClassType.Value)
{
converterList = jsonPropertyInfo.ElementClassInfo.PolicyProperty.CreateConverterList();
}
else
{
converterList = new List <object>();
}
state.Current.TempEnumerableValues = converterList;
// Clear the value if present to ensure we don't confuse tempEnumerableValues with the collection.
if (!jsonPropertyInfo.IsPropertyPolicy &&
!state.Current.JsonPropertyInfo.RuntimePropertyType.FullName.StartsWith(DefaultImmutableEnumerableConverter.ImmutableArrayGenericTypeName))
{
jsonPropertyInfo.SetValueAsObject(state.Current.ReturnValue, null);
}
return(null);
}
Type propertyType = jsonPropertyInfo.RuntimePropertyType;
if (typeof(IList).IsAssignableFrom(propertyType))
{
// If IList, add the members as we create them.
JsonClassInfo collectionClassInfo;
if (jsonPropertyInfo.DeclaredPropertyType == jsonPropertyInfo.ImplementedPropertyType)
{
collectionClassInfo = jsonPropertyInfo.RuntimeClassInfo;
}
else
{
collectionClassInfo = jsonPropertyInfo.DeclaredTypeClassInfo;
}
if (collectionClassInfo.CreateObject() is IList collection)
{
return(collection);
}
else
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(jsonPropertyInfo.DeclaredPropertyType, reader, state.JsonPath());
return(null);
}
}
else
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(propertyType, reader, state.JsonPath());
return(null);
}
}