internal IEnumerable <string> SerializeMultiValueType(SerializationInfo serializationInfo, int currentIndentation, int currentObjectDepth,
EFormatOption keyFormatOption, EFormatOption valueFormatOption)
{
if (serializationInfo.dataInstance == null)
{
return(new string[] { });
}
if (!serializationInfo.eDataType.IsMultiValueType())
{
throw new ArgumentOutOfRangeException("eDataType: " + serializationInfo.eDataType + " is not a multi-value Type!");
}
switch (serializationInfo.eDataType)
{
case EDataType.GenericList: {
IList list = (IList)serializationInfo.dataInstance;
Type valueType = serializationInfo.dataType.GetGenericArguments()[0];
EDataType valueEDataType = EDataTypes_Extensions.GetDataType(valueType);
return((
from object value in list
select new SerializationInfo(value, valueType, valueEDataType)
into valueSerializationInfo
select SerializeListValue(valueSerializationInfo, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption)
).SelectMany(sList => sList));
}
case EDataType.GenericDictionary: {
IDictionary dictionary = (IDictionary)serializationInfo.dataInstance;
Type keyType = serializationInfo.dataType.GetGenericArguments()[0];
EDataType eKeyType = EDataTypes_Extensions.GetDataType(keyType);
Type valueType = serializationInfo.dataType.GetGenericArguments()[1];
EDataType eValueType = EDataTypes_Extensions.GetDataType(valueType);
if (!eKeyType.IsSingleValueType())
{
throw new InvalidDataException("Key of Config Dictionary must be Single-Value Type!");
}
List <string> result = new List <string>();
foreach (DictionaryEntry entry in dictionary)
{
SerializationInfo keyInfo = new SerializationInfo(entry.Key, keyType, eKeyType);
SerializationInfo valueInfo = new SerializationInfo(entry.Value, valueType, eValueType);
result.AddRange(SerializeDictionaryEntry(keyInfo, valueInfo, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption));
}
return(result);
}
case EDataType.NonGenericClass:
return(SerializeNonGenericClass(serializationInfo, currentIndentation, currentObjectDepth, keyFormatOption, valueFormatOption));
case EDataType.TypeConvertibleClass:
case EDataType.Enum:
case EDataType.Primitive:
case EDataType.String:
default:
throw new ArgumentOutOfRangeException();
}
}
private object DeserializeSingleFieldType(TokenNode node, Type objectType, object instanceToUse, IReadOnlyList <FieldInfo> fieldChain)
{
int fieldCount = fieldChain.Count;
if (fieldCount <= 0)
{
throw new InvalidDataException($"Tried to Deserialize SingleFieldType '{objectType.FullName}' but did not find any Fields!");
}
FieldInfo lastField = fieldChain[fieldCount - 1];
EDataType lastEType = EDataTypes_Extensions.GetDataType(lastField.FieldType);
bool isSingleValueType = lastEType.IsSingleValueType();
if (isSingleValueType && node.simpleValue == null ||
!isSingleValueType && node.listValues.Count == 0)
{
return(null);
}
object lastFieldValue = DeserializeNodeValue(node, lastField.FieldType, lastEType);
if (lastFieldValue == null)
{
return(null);
}
object resultInstance = instanceToUse ?? Activator.CreateInstance(objectType);
object lastInstance = resultInstance;
for (int i = 0; i < fieldCount - 1; i++)
{
FieldInfo fieldInfo = fieldChain[i];
object fieldValue = Activator.CreateInstance(fieldInfo.FieldType);
fieldInfo.SetValue(lastInstance, fieldValue);
lastInstance = fieldValue;
}
lastField.SetValue(lastInstance, lastFieldValue);
return(resultInstance);
}
public static bool IsMultiValueType(this EDataType eDataType)
{
return(!eDataType.IsSingleValueType());
}