private static bool HandleEnumerable(
JsonClassInfo elementClassInfo,
JsonSerializerOptions options,
ref Utf8JsonWriter writer,
ref WriteStack state)
{
Debug.Assert(state.Current.JsonPropertyInfo.ClassType == ClassType.Enumerable);
JsonPropertyInfo propertyInfo = state.Current.JsonPropertyInfo;
if (state.Current.Enumerator == null)
{
if (propertyInfo._name == null)
{
writer.WriteStartArray();
}
else
{
writer.WriteStartArray(propertyInfo._name);
}
IEnumerable enumerable = (IEnumerable)propertyInfo.GetValueAsObject(state.Current.CurrentValue, options);
if (enumerable != null)
{
state.Current.Enumerator = enumerable.GetEnumerator();
}
}
if (state.Current.Enumerator != null && state.Current.Enumerator.MoveNext())
{
if (elementClassInfo.ClassType == ClassType.Value)
{
elementClassInfo.GetPolicyProperty().WriteEnumerable(options, ref state.Current, ref writer);
}
else
{
// An object or another enumerator requires a new stack frame
JsonClassInfo nextClassInfo = propertyInfo.ElementClassInfo;
object nextValue = state.Current.Enumerator.Current;
state.Push(nextClassInfo, nextValue);
}
return(false);
}
// We are done enumerating.
writer.WriteEndArray();
if (state.Current.PopStackOnEndArray)
{
state.Pop();
}
else
{
state.Current.EndArray();
}
return(true);
}
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.PropertyInitialized)
{
Debug.Assert(state.Current.IsDictionary);
JsonClassInfo classInfoTemp = state.Current.JsonClassInfo;
state.Push();
state.Current.JsonClassInfo = classInfoTemp.ElementClassInfo;
state.Current.InitializeJsonPropertyInfo();
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.PropertyPath);
}
JsonClassInfo classInfo = state.Current.JsonClassInfo;
state.Current.ReturnValue = classInfo.CreateObject();
return;
}
state.Current.PropertyInitialized = true;
// If current property is already set (from a constructor, for example) leave as-is.
if (jsonPropertyInfo.GetValueAsObject(state.Current.ReturnValue) == null)
{
// Create the dictionary.
JsonClassInfo dictionaryClassInfo = options.GetOrAddClass(jsonPropertyInfo.RuntimePropertyType);
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);
}
}
}
}
private static bool HandleObject(
JsonSerializerOptions options,
ref Utf8JsonWriter writer,
ref WriteObjectState current,
ref List <WriteObjectState> previous,
ref int arrayIndex)
{
Debug.Assert(current.ClassInfo.ClassType == ClassType.Object);
JsonPropertyInfo propertyInfo = current.ClassInfo.GetProperty(current.PropertyIndex);
current.PropertyInfo = propertyInfo;
ClassType propertyClassType = propertyInfo.ClassType;
if (propertyClassType == ClassType.Value)
{
propertyInfo.Write(options, ref current, ref writer);
current.NextProperty();
return(true);
}
// A property that returns an enumerator keeps the same stack frame.
if (propertyClassType == ClassType.Enumerable)
{
bool endOfEnumerable = HandleEnumerable(propertyInfo.ElementClassInfo, options, ref writer, ref current, ref previous, ref arrayIndex);
if (endOfEnumerable)
{
current.NextProperty();
}
return(endOfEnumerable);
}
// A property that returns an object requires a new stack frame.
object value = propertyInfo.GetValueAsObject(current.CurrentValue, options);
if (value != null)
{
JsonPropertyInfo previousPropertyInfo = current.PropertyInfo;
current.NextProperty();
JsonClassInfo nextClassInfo = options.GetOrAddClass(propertyInfo.PropertyType);
AddNewStackFrame(nextClassInfo, value, ref current, ref previous, ref arrayIndex);
// Set the PropertyInfo so we can obtain the property name in order to write it.
current.PropertyInfo = previousPropertyInfo;
}
else if (!propertyInfo.IgnoreNullPropertyValueOnWrite(options))
{
writer.WriteNull(propertyInfo.Name);
}
return(true);
}
private static void ProcessMissingProperty(
ReadOnlySpan <byte> unescapedPropertyName,
JsonSerializerOptions options,
ref Utf8JsonReader reader,
ref ReadStack state)
{
// Remember the property name to support Path.
state.Current.JsonPropertyName = unescapedPropertyName.ToArray();
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonClassInfo.DataExtensionProperty;
Debug.Assert(jsonPropertyInfo != null);
Debug.Assert(state.Current.ReturnValue != null);
IDictionary extensionData = (IDictionary)jsonPropertyInfo.GetValueAsObject(state.Current.ReturnValue);
if (extensionData == null)
{
// Create the appropriate dictionary type. We already verified the types.
Debug.Assert(jsonPropertyInfo.DeclaredPropertyType.IsGenericType);
Debug.Assert(jsonPropertyInfo.DeclaredPropertyType.GetGenericArguments().Length == 2);
Debug.Assert(jsonPropertyInfo.DeclaredPropertyType.GetGenericArguments()[0].UnderlyingSystemType == typeof(string));
Debug.Assert(
jsonPropertyInfo.DeclaredPropertyType.GetGenericArguments()[1].UnderlyingSystemType == typeof(object) ||
jsonPropertyInfo.DeclaredPropertyType.GetGenericArguments()[1].UnderlyingSystemType == typeof(JsonElement));
extensionData = (IDictionary)jsonPropertyInfo.RuntimeClassInfo.CreateObject();
jsonPropertyInfo.SetValueAsObject(state.Current.ReturnValue, extensionData);
}
JsonElement jsonElement;
using (JsonDocument jsonDocument = JsonDocument.ParseValue(ref reader))
{
jsonElement = jsonDocument.RootElement.Clone();
}
string keyName = JsonHelpers.Utf8GetString(unescapedPropertyName);
// Currently we don't apply any naming policy. If we do, we'd have to pass it onto the JsonDocument.
extensionData.Add(keyName, jsonElement);
}
private static void HandleStartArray(
JsonSerializerOptions options,
ref Utf8JsonReader reader,
ref ReadStack state)
{
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
bool skip = jsonPropertyInfo != null && !jsonPropertyInfo.ShouldDeserialize;
if (skip || state.Current.Skip())
{
// The array is not being applied to the object.
state.Push();
state.Current.Drain = true;
return;
}
if (jsonPropertyInfo == null || state.Current.JsonClassInfo.ClassType == ClassType.Unknown)
{
jsonPropertyInfo = state.Current.JsonClassInfo.CreatePolymorphicProperty(jsonPropertyInfo, typeof(object), options);
}
Type arrayType = jsonPropertyInfo.RuntimePropertyType;
if (!typeof(IEnumerable).IsAssignableFrom(arrayType) || (arrayType.IsArray && arrayType.GetArrayRank() > 1))
{
ThrowHelper.ThrowJsonReaderException_DeserializeUnableToConvertValue(arrayType, reader, state);
}
Debug.Assert(state.Current.IsPropertyEnumerable());
if (state.Current.IsPropertyEnumerable())
{
if (state.Current.EnumerableCreated)
{
// A nested json array so push a new stack frame.
Type elementType = state.Current.JsonClassInfo.ElementClassInfo.GetPolicyProperty().RuntimePropertyType;
state.Push();
state.Current.Initialize(elementType, options);
state.Current.PopStackOnEndArray = true;
}
else
{
state.Current.EnumerableCreated = true;
}
jsonPropertyInfo = state.Current.JsonPropertyInfo;
// If current property is already set (from a constructor, for example) leave as-is
if (jsonPropertyInfo.GetValueAsObject(state.Current.ReturnValue, options) == null)
{
// Create the enumerable.
object value = ReadStackFrame.CreateEnumerableValue(ref reader, ref state, options);
if (value != null)
{
if (state.Current.ReturnValue != null)
{
state.Current.JsonPropertyInfo.SetValueAsObject(state.Current.ReturnValue, value, options);
}
else
{
// Primitive arrays being returned without object
state.Current.SetReturnValue(value, options);
}
}
}
}
}
private static bool HandleObject(
JsonSerializerOptions options,
Utf8JsonWriter writer,
ref WriteStack state)
{
Debug.Assert(
state.Current.JsonClassInfo.ClassType == ClassType.Object ||
state.Current.JsonClassInfo.ClassType == ClassType.Unknown);
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonClassInfo.GetProperty(state.Current.PropertyIndex);
bool obtainedValue = false;
object currentValue = null;
// Check for polymorphism.
if (jsonPropertyInfo.ClassType == ClassType.Unknown)
{
currentValue = jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue);
obtainedValue = true;
GetRuntimePropertyInfo(currentValue, state.Current.JsonClassInfo, ref jsonPropertyInfo, options);
}
state.Current.JsonPropertyInfo = jsonPropertyInfo;
if (jsonPropertyInfo.ClassType == ClassType.Value)
{
jsonPropertyInfo.Write(options, ref state.Current, writer);
state.Current.NextProperty();
return(true);
}
// A property that returns an enumerator keeps the same stack frame.
if (jsonPropertyInfo.ClassType == ClassType.Enumerable)
{
bool endOfEnumerable = HandleEnumerable(jsonPropertyInfo.ElementClassInfo, options, writer, ref state);
if (endOfEnumerable)
{
state.Current.NextProperty();
}
return(endOfEnumerable);
}
// A property that returns a dictionary keeps the same stack frame.
if (jsonPropertyInfo.ClassType == ClassType.Dictionary)
{
bool endOfEnumerable = HandleDictionary(jsonPropertyInfo.ElementClassInfo, options, writer, ref state);
if (endOfEnumerable)
{
state.Current.NextProperty();
}
return(endOfEnumerable);
}
// A property that returns an object.
if (!obtainedValue)
{
currentValue = jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue);
}
if (currentValue != null)
{
// A new stack frame is required.
JsonPropertyInfo previousPropertyInfo = state.Current.JsonPropertyInfo;
state.Current.NextProperty();
JsonClassInfo nextClassInfo = options.GetOrAddClass(jsonPropertyInfo.RuntimePropertyType);
state.Push(nextClassInfo, currentValue);
// Set the PropertyInfo so we can obtain the property name in order to write it.
state.Current.JsonPropertyInfo = previousPropertyInfo;
}
else
{
if (!jsonPropertyInfo.IgnoreNullValues)
{
writer.WriteNull(jsonPropertyInfo._escapedName);
}
state.Current.NextProperty();
}
return(true);
}
private static void HandleStartArray(
JsonSerializerOptions options,
ref Utf8JsonReader reader,
ref ReadStack state)
{
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (state.Current.SkipProperty)
{
// The array is not being applied to the object.
state.Push();
state.Current.Drain = true;
return;
}
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 don't have a multidimensional array.
Type arrayType = jsonPropertyInfo.RuntimePropertyType;
if (!typeof(IEnumerable).IsAssignableFrom(arrayType) || (arrayType.IsArray && arrayType.GetArrayRank() > 1))
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(arrayType, reader, state.PropertyPath);
}
Debug.Assert(state.Current.IsProcessingEnumerableOrDictionary);
if (state.Current.PropertyInitialized)
{
// A nested json array so push a new stack frame.
Type elementType = jsonPropertyInfo.ElementClassInfo.Type;
state.Push();
state.Current.Initialize(elementType, options);
state.Current.PropertyInitialized = true;
}
else
{
state.Current.PropertyInitialized = true;
}
jsonPropertyInfo = state.Current.JsonPropertyInfo;
// If current property is already set (from a constructor, for example) leave as-is.
if (jsonPropertyInfo.GetValueAsObject(state.Current.ReturnValue) == null)
{
// Create the enumerable.
object value = ReadStackFrame.CreateEnumerableValue(ref reader, ref state, options);
// 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);
}
}
}
}
private static bool HandleEnumerable(
JsonClassInfo elementClassInfo,
JsonSerializerOptions options,
ref Utf8JsonWriter writer,
ref WriteStack state)
{
Debug.Assert(state.Current.JsonPropertyInfo.ClassType == ClassType.Enumerable);
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (state.Current.Enumerator == null)
{
if (jsonPropertyInfo._name == null)
{
writer.WriteStartArray();
}
else
{
writer.WriteStartArray(jsonPropertyInfo._name);
}
IEnumerable enumerable = (IEnumerable)jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue, options);
if (enumerable != null)
{
state.Current.Enumerator = enumerable.GetEnumerator();
}
}
if (state.Current.Enumerator != null && state.Current.Enumerator.MoveNext())
{
// Check for polymorphism.
if (elementClassInfo.ClassType == ClassType.Unknown)
{
object currentValue = state.Current.Enumerator.Current;
GetRuntimeClassInfo(currentValue, ref elementClassInfo, options);
}
if (elementClassInfo.ClassType == ClassType.Value)
{
elementClassInfo.GetPolicyProperty().WriteEnumerable(options, ref state.Current, ref writer);
}
else if (state.Current.Enumerator.Current == null)
{
// Write a null object or enumerable.
writer.WriteNullValue();
}
else
{
// An object or another enumerator requires a new stack frame.
object nextValue = state.Current.Enumerator.Current;
state.Push(elementClassInfo, nextValue);
}
return(false);
}
// We are done enumerating.
writer.WriteEndArray();
if (state.Current.PopStackOnEndArray)
{
state.Pop();
}
else
{
state.Current.EndArray();
}
return(true);
}
private static bool HandleObject(
JsonSerializerOptions options,
ref Utf8JsonWriter writer,
ref WriteStack state)
{
Debug.Assert(state.Current.JsonClassInfo.ClassType == ClassType.Object);
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonClassInfo.GetProperty(state.Current.PropertyIndex);
ClassType propertyClassType = jsonPropertyInfo.ClassType;
bool obtainedValue = false;
object currentValue = null;
// Check for polymorphism.
if (jsonPropertyInfo.RuntimePropertyType == typeof(object))
{
Debug.Assert(propertyClassType == ClassType.Object);
currentValue = jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue, options);
obtainedValue = true;
if (currentValue != null)
{
Type runtimeType = currentValue.GetType();
// Ignore object() instances since they are handled as an empty object.
if (runtimeType != typeof(object))
{
propertyClassType = JsonClassInfo.GetClassType(runtimeType);
jsonPropertyInfo = state.Current.JsonClassInfo.CreatePolymorphicProperty(jsonPropertyInfo, runtimeType, options);
}
}
}
state.Current.JsonPropertyInfo = jsonPropertyInfo;
if (propertyClassType == ClassType.Value)
{
jsonPropertyInfo.Write(options, ref state.Current, ref writer);
state.Current.NextProperty();
return(true);
}
// A property that returns an enumerator keeps the same stack frame.
if (propertyClassType == ClassType.Enumerable)
{
bool endOfEnumerable = HandleEnumerable(jsonPropertyInfo.ElementClassInfo, options, ref writer, ref state);
if (endOfEnumerable)
{
state.Current.NextProperty();
}
return(endOfEnumerable);
}
// A property that returns an object.
if (!obtainedValue)
{
currentValue = jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue, options);
}
if (currentValue != null)
{
// A new stack frame is required.
JsonPropertyInfo previousPropertyInfo = state.Current.JsonPropertyInfo;
state.Current.NextProperty();
JsonClassInfo nextClassInfo = options.GetOrAddClass(jsonPropertyInfo.RuntimePropertyType);
state.Push(nextClassInfo, currentValue);
// Set the PropertyInfo so we can obtain the property name in order to write it.
state.Current.JsonPropertyInfo = previousPropertyInfo;
}
else
{
if (!jsonPropertyInfo.IgnoreNullPropertyValueOnWrite(options))
{
writer.WriteNull(jsonPropertyInfo._escapedName);
}
state.Current.NextProperty();
}
return(true);
}
private static bool HandleEnumerable(
JsonClassInfo elementClassInfo,
JsonSerializerOptions options,
ref Utf8JsonWriter writer,
ref WriteObjectState current,
ref List <WriteObjectState> previous,
ref int arrayIndex)
{
Debug.Assert(current.PropertyInfo.ClassType == ClassType.Enumerable);
JsonPropertyInfo propertyInfo = current.PropertyInfo;
if (current.Enumerator == null)
{
if (propertyInfo.Name == null)
{
writer.WriteStartArray();
}
else
{
writer.WriteStartArray(propertyInfo.Name);
}
IEnumerable enumerable = (IEnumerable)propertyInfo.GetValueAsObject(current.CurrentValue, options);
if (enumerable != null)
{
current.Enumerator = enumerable.GetEnumerator();
}
}
if (current.Enumerator != null && current.Enumerator.MoveNext())
{
if (elementClassInfo.ClassType == ClassType.Value)
{
propertyInfo.Write(options, ref current, ref writer);
}
else
{
// An object or another enumerator requires a new stack frame
JsonClassInfo nextClassInfo = propertyInfo.ElementClassInfo;
object nextValue = current.Enumerator.Current;
AddNewStackFrame(nextClassInfo, nextValue, ref current, ref previous, ref arrayIndex);
}
return(false);
}
// We are done enumerating.
writer.WriteEndArray();
if (current.PopStackOnEndArray)
{
WriteObjectState previousFrame = default;
GetPreviousState(ref previous, ref previousFrame, --arrayIndex);
current = previousFrame;
}
else
{
current.EndArray();
}
return(true);
}
private static bool HandleDictionary(
JsonClassInfo elementClassInfo,
JsonSerializerOptions options,
Utf8JsonWriter writer,
ref WriteStack state)
{
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (state.Current.Enumerator == null)
{
IEnumerable enumerable;
enumerable = (IEnumerable)jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue);
if (enumerable == null)
{
// Write a null object or enumerable.
state.Current.WriteObjectOrArrayStart(ClassType.Dictionary, writer, writeNull: true);
return(true);
}
state.Current.Enumerator = enumerable.GetEnumerator();
state.Current.WriteObjectOrArrayStart(ClassType.Dictionary, writer);
}
if (state.Current.Enumerator.MoveNext())
{
// Handle DataExtension.
if (ReferenceEquals(jsonPropertyInfo, state.Current.JsonClassInfo.DataExtensionProperty))
{
WriteExtensionData(writer, ref state.Current);
}
else
{
// Check for polymorphism.
if (elementClassInfo.ClassType == ClassType.Unknown)
{
object currentValue = ((IDictionaryEnumerator)state.Current.Enumerator).Entry.Value;
GetRuntimeClassInfo(currentValue, ref elementClassInfo, options);
}
if (elementClassInfo.ClassType == ClassType.Value)
{
elementClassInfo.GetPolicyProperty().WriteDictionary(ref state.Current, writer);
}
else if (state.Current.Enumerator.Current == null)
{
writer.WriteNull(jsonPropertyInfo.Name);
}
else
{
// An object or another enumerator requires a new stack frame.
var enumerator = (IDictionaryEnumerator)state.Current.Enumerator;
object value = enumerator.Value;
state.Push(elementClassInfo, value);
state.Current.KeyName = (string)enumerator.Key;
}
}
return(false);
}
// We are done enumerating.
writer.WriteEndObject();
if (state.Current.PopStackOnEnd)
{
state.Pop();
}
else
{
state.Current.EndDictionary();
}
return(true);
}
private static bool HandleEnumerable(
JsonClassInfo elementClassInfo,
JsonSerializerOptions options,
ref Utf8JsonWriter writer,
ref WriteStack state)
{
Debug.Assert(state.Current.JsonPropertyInfo.ClassType == ClassType.Enumerable);
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (state.Current.Enumerator == null)
{
if (jsonPropertyInfo._name == null)
{
writer.WriteStartArray();
}
else
{
writer.WriteStartArray(jsonPropertyInfo._name);
}
IEnumerable enumerable = (IEnumerable)jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue, options);
if (enumerable != null)
{
state.Current.Enumerator = enumerable.GetEnumerator();
}
}
if (state.Current.Enumerator != null && state.Current.Enumerator.MoveNext())
{
// If the enumerator contains typeof(object), get the run-time type
if (elementClassInfo.ClassType == ClassType.Object && jsonPropertyInfo.ElementClassInfo.Type == typeof(object))
{
object currentValue = state.Current.Enumerator.Current;
if (currentValue != null)
{
Type runtimeType = currentValue.GetType();
// Ignore object() instances since they are handled as an empty object.
if (runtimeType != typeof(object))
{
elementClassInfo = options.GetOrAddClass(runtimeType);
}
}
}
if (elementClassInfo.ClassType == ClassType.Value)
{
elementClassInfo.GetPolicyProperty().WriteEnumerable(options, ref state.Current, ref writer);
}
else if (state.Current.Enumerator.Current == null)
{
// Write a null object or enumerable.
writer.WriteNullValue();
}
else
{
// An object or another enumerator requires a new stack frame.
object nextValue = state.Current.Enumerator.Current;
state.Push(elementClassInfo, nextValue);
}
return(false);
}
// We are done enumerating.
writer.WriteEndArray();
if (state.Current.PopStackOnEndArray)
{
state.Pop();
}
else
{
state.Current.EndArray();
}
return(true);
}
private static bool HandleDictionary(
JsonClassInfo elementClassInfo,
JsonSerializerOptions options,
Utf8JsonWriter writer,
ref WriteStack state)
{
Debug.Assert(state.Current.JsonPropertyInfo.ClassType == ClassType.Dictionary);
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (!jsonPropertyInfo.ShouldSerialize)
{
// Ignore writing this property.
return(true);
}
if (state.Current.Enumerator == null)
{
IEnumerable enumerable = (IEnumerable)jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue, options);
if (enumerable == null)
{
// Write a null object or enumerable.
writer.WriteNull(jsonPropertyInfo.Name);
return(true);
}
state.Current.Enumerator = enumerable.GetEnumerator();
if (jsonPropertyInfo.Name == null)
{
writer.WriteStartObject();
}
else
{
writer.WriteStartObject(jsonPropertyInfo.Name);
}
}
if (state.Current.Enumerator.MoveNext())
{
// Check for polymorphism.
if (elementClassInfo.ClassType == ClassType.Unknown)
{
//todo:test
object currentValue = ((IDictionaryEnumerator)(state.Current.Enumerator)).Entry;
GetRuntimeClassInfo(currentValue, ref elementClassInfo, options);
}
if (elementClassInfo.ClassType == ClassType.Value)
{
elementClassInfo.GetPolicyProperty().WriteDictionary(options, ref state.Current, writer);
}
else if (state.Current.Enumerator.Current == null)
{
writer.WriteNull(jsonPropertyInfo.Name);
}
else
{
// An object or another enumerator requires a new stack frame.
object nextValue = state.Current.Enumerator.Current;
state.Push(elementClassInfo, nextValue);
}
return(false);
}
// We are done enumerating.
writer.WriteEndObject();
state.Current.EndDictionary();
return(true);
}
private static bool HandleDictionary(
JsonClassInfo elementClassInfo,
JsonSerializerOptions options,
Utf8JsonWriter writer,
ref WriteStack state)
{
JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
if (!jsonPropertyInfo.ShouldSerialize)
{
// Ignore writing this property.
return(true);
}
if (state.Current.Enumerator == null)
{
// Verify that the Dictionary can be serialized by having <string> as first generic argument.
Type[] args = jsonPropertyInfo.RuntimePropertyType.GetGenericArguments();
if (args.Length == 0 || args[0].UnderlyingSystemType != typeof(string))
{
ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(state.Current.JsonClassInfo.Type, state.PropertyPath);
}
IEnumerable enumerable = (IEnumerable)jsonPropertyInfo.GetValueAsObject(state.Current.CurrentValue);
if (enumerable == null)
{
// Write a null object or enumerable.
state.Current.WriteObjectOrArrayStart(ClassType.Dictionary, writer, writeNull: true);
return(true);
}
state.Current.Enumerator = enumerable.GetEnumerator();
state.Current.WriteObjectOrArrayStart(ClassType.Dictionary, writer);
}
if (state.Current.Enumerator.MoveNext())
{
// Check for polymorphism.
if (elementClassInfo.ClassType == ClassType.Unknown)
{
object currentValue = ((IDictionaryEnumerator)state.Current.Enumerator).Entry.Value;
GetRuntimeClassInfo(currentValue, ref elementClassInfo, options);
}
if (elementClassInfo.ClassType == ClassType.Value)
{
elementClassInfo.GetPolicyProperty().WriteDictionary(options, ref state.Current, writer);
}
else if (state.Current.Enumerator.Current == null)
{
writer.WriteNull(jsonPropertyInfo.Name);
}
else
{
// An object or another enumerator requires a new stack frame.
var enumerator = (IDictionaryEnumerator)state.Current.Enumerator;
object value = enumerator.Value;
state.Push(elementClassInfo, value);
state.Current.KeyName = (string)enumerator.Key;
}
return(false);
}
// We are done enumerating.
writer.WriteEndObject();
if (state.Current.PopStackOnEnd)
{
state.Pop();
}
else
{
state.Current.EndDictionary();
}
return(true);
}