|
static private WriteJsonValue ( |
||
| contract | ||
| writer | XmlWriterDelegator | |
| graph | object | |
| context | System.Runtime.Serialization.Json.XmlObjectSerializerWriteContextComplexJson | |
| declaredTypeHandle | ||
| return | void | |
protected override void WriteDataContractValue(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle declaredTypeHandle)
{
JsonDataContract jsonDataContract = JsonDataContract.GetJsonDataContract(dataContract);
if (_emitXsiType == EmitTypeInformation.Always && !_perCallXsiTypeAlreadyEmitted && RequiresJsonTypeInfo(dataContract))
{
WriteTypeInfo(xmlWriter, jsonDataContract.TypeName !);
}
_perCallXsiTypeAlreadyEmitted = false;
DataContractJsonSerializer.WriteJsonValue(jsonDataContract, xmlWriter, obj, this, declaredTypeHandle);
}
protected override void WriteDataContractValue(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle declaredTypeHandle)
{
JsonDataContract jsonDataContract = JsonDataContract.GetJsonDataContract(dataContract);
if ((this.alwaysEmitXsiType && !this.perCallXsiTypeAlreadyEmitted) && RequiresJsonTypeInfo(dataContract))
{
this.WriteTypeInfo(xmlWriter, jsonDataContract.TypeName);
}
this.perCallXsiTypeAlreadyEmitted = false;
DataContractJsonSerializer.WriteJsonValue(jsonDataContract, xmlWriter, obj, this, declaredTypeHandle);
}
internal override void InternalWriteObjectContent(XmlWriterDelegator writer, object?graph)
{
if (MaxItemsInObjectGraph == 0)
{
throw XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ExceededMaxItemsQuota, MaxItemsInObjectGraph));
}
DataContract contract = RootContract;
Type declaredType = contract.UnderlyingType;
Type graphType = (graph == null) ? declaredType : graph.GetType();
if (_serializationSurrogateProvider != null)
{
graph = DataContractSerializer.SurrogateToDataContractType(_serializationSurrogateProvider, graph, declaredType, ref graphType);
}
if (graph == null)
{
WriteJsonNull(writer);
}
else
{
if (declaredType == graphType)
{
if (contract.CanContainReferences)
{
XmlObjectSerializerWriteContextComplexJson context = XmlObjectSerializerWriteContextComplexJson.CreateContext(this, contract);
context.OnHandleReference(writer, graph, true); // canContainReferences
context.SerializeWithoutXsiType(contract, writer, graph, declaredType.TypeHandle);
}
else
{
DataContractJsonSerializer.WriteJsonValue(JsonDataContract.GetJsonDataContract(contract), writer, graph, null, declaredType.TypeHandle); // XmlObjectSerializerWriteContextComplexJson
}
}
else
{
XmlObjectSerializerWriteContextComplexJson context = XmlObjectSerializerWriteContextComplexJson.CreateContext(this, RootContract);
contract = DataContractJsonSerializer.GetDataContract(contract, declaredType, graphType);
if (contract.CanContainReferences)
{
context.OnHandleReference(writer, graph, true); // canContainCyclicReference
context.SerializeWithXsiTypeAtTopLevel(contract, writer, graph, declaredType.TypeHandle, graphType);
}
else
{
context.SerializeWithoutXsiType(contract, writer, graph, declaredType.TypeHandle);
}
}
}
}
void WriteCollection(CollectionDataContract collectionContract)
{
XmlDictionaryString itemName = context.CollectionItemName;
if (collectionContract.Kind == CollectionKind.Array)
{
Type itemType = collectionContract.ItemType;
int i;
// This check does not exist in the original dynamic code,
// but there is no other way to check type mismatch.
// CollectionSerialization.ArrayContract() shows that it is required.
if (objLocal.GetType().GetElementType() != itemType)
{
throw new InvalidCastException(string.Format("Cannot cast array of {0} to array of {1}", objLocal.GetType().GetElementType(), itemType));
}
context.IncrementArrayCount(writer, (Array)objLocal);
if (!TryWritePrimitiveArray(collectionContract.UnderlyingType, itemType, () => objLocal, itemName))
{
WriteArrayAttribute();
var arr = (Array)objLocal;
var idx = new int [1];
for (i = 0; i < arr.Length; i++)
{
if (!TryWritePrimitive(itemType, null, null, i, itemName, 0))
{
WriteStartElement(itemName, 0);
idx [0] = i;
var mbrVal = arr.GetValue(idx);
WriteValue(itemType, mbrVal);
WriteEndElement();
}
}
}
}
else
{
// This check does not exist in the original dynamic code,
// but there is no other way to check type mismatch.
// CollectionSerialization.ArrayContract() shows that it is required.
if (!collectionContract.UnderlyingType.IsAssignableFrom(objLocal.GetType()))
{
throw new InvalidCastException(string.Format("Cannot cast {0} to {1}", objLocal.GetType(), collectionContract.UnderlyingType));
}
MethodInfo incrementCollectionCountMethod = null;
switch (collectionContract.Kind)
{
case CollectionKind.Collection:
case CollectionKind.List:
case CollectionKind.Dictionary:
incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountMethod;
break;
case CollectionKind.GenericCollection:
case CollectionKind.GenericList:
incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(collectionContract.ItemType);
break;
case CollectionKind.GenericDictionary:
incrementCollectionCountMethod = XmlFormatGeneratorStatics.IncrementCollectionCountGenericMethod.MakeGenericMethod(Globals.TypeOfKeyValuePair.MakeGenericType(collectionContract.ItemType.GetGenericArguments()));
break;
}
if (incrementCollectionCountMethod != null)
{
incrementCollectionCountMethod.Invoke(context, new object [] { writer, objLocal });
}
bool isDictionary = false, isGenericDictionary = false;
Type enumeratorType = null;
Type [] keyValueTypes = null;
if (collectionContract.Kind == CollectionKind.GenericDictionary)
{
isGenericDictionary = true;
keyValueTypes = collectionContract.ItemType.GetGenericArguments();
enumeratorType = Globals.TypeOfGenericDictionaryEnumerator.MakeGenericType(keyValueTypes);
}
else if (collectionContract.Kind == CollectionKind.Dictionary)
{
isDictionary = true;
keyValueTypes = new Type[] { Globals.TypeOfObject, Globals.TypeOfObject };
enumeratorType = Globals.TypeOfDictionaryEnumerator;
}
else
{
enumeratorType = collectionContract.GetEnumeratorMethod.ReturnType;
}
MethodInfo moveNextMethod = enumeratorType.GetMethod(Globals.MoveNextMethodName, BindingFlags.Instance | BindingFlags.Public, null, Globals.EmptyTypeArray, null);
MethodInfo getCurrentMethod = enumeratorType.GetMethod(Globals.GetCurrentMethodName, BindingFlags.Instance | BindingFlags.Public, null, Globals.EmptyTypeArray, null);
if (moveNextMethod == null || getCurrentMethod == null)
{
if (enumeratorType.IsInterface)
{
if (moveNextMethod == null)
{
moveNextMethod = JsonFormatGeneratorStatics.MoveNextMethod;
}
if (getCurrentMethod == null)
{
getCurrentMethod = JsonFormatGeneratorStatics.GetCurrentMethod;
}
}
else
{
Type ienumeratorInterface = Globals.TypeOfIEnumerator;
CollectionKind kind = collectionContract.Kind;
if (kind == CollectionKind.GenericDictionary || kind == CollectionKind.GenericCollection || kind == CollectionKind.GenericEnumerable)
{
Type[] interfaceTypes = enumeratorType.GetInterfaces();
foreach (Type interfaceType in interfaceTypes)
{
if (interfaceType.IsGenericType &&
interfaceType.GetGenericTypeDefinition() == Globals.TypeOfIEnumeratorGeneric &&
interfaceType.GetGenericArguments()[0] == collectionContract.ItemType)
{
ienumeratorInterface = interfaceType;
break;
}
}
}
if (moveNextMethod == null)
{
moveNextMethod = CollectionDataContract.GetTargetMethodWithName(Globals.MoveNextMethodName, enumeratorType, ienumeratorInterface);
}
if (getCurrentMethod == null)
{
getCurrentMethod = CollectionDataContract.GetTargetMethodWithName(Globals.GetCurrentMethodName, enumeratorType, ienumeratorInterface);
}
}
}
Type elementType = getCurrentMethod.ReturnType;
object currentValue = null; // of elementType
var enumerator = (IEnumerator)collectionContract.GetEnumeratorMethod.Invoke(objLocal, new object [0]);
if (isDictionary)
{
ConstructorInfo dictEnumCtor = enumeratorType.GetConstructor(Globals.ScanAllMembers, null, new Type[] { Globals.TypeOfIDictionaryEnumerator }, null);
enumerator = (IEnumerator)dictEnumCtor.Invoke(new object [] { enumerator });
}
else if (isGenericDictionary)
{
Type ctorParam = Globals.TypeOfIEnumeratorGeneric.MakeGenericType(Globals.TypeOfKeyValuePair.MakeGenericType(keyValueTypes));
ConstructorInfo dictEnumCtor = enumeratorType.GetConstructor(Globals.ScanAllMembers, null, new Type[] { ctorParam }, null);
enumerator = (IEnumerator)Activator.CreateInstance(enumeratorType, new object [] { enumerator });
}
bool canWriteSimpleDictionary = isDictionary || isGenericDictionary;
bool writeSimpleDictionary = canWriteSimpleDictionary && context.UseSimpleDictionaryFormat;
PropertyInfo genericDictionaryKeyProperty = null, genericDictionaryValueProperty = null;
if (canWriteSimpleDictionary)
{
Type genericDictionaryKeyValueType = Globals.TypeOfKeyValue.MakeGenericType(keyValueTypes);
genericDictionaryKeyProperty = genericDictionaryKeyValueType.GetProperty(JsonGlobals.KeyString);
genericDictionaryValueProperty = genericDictionaryKeyValueType.GetProperty(JsonGlobals.ValueString);
}
if (writeSimpleDictionary)
{
WriteObjectAttribute();
object key, value;
var empty_args = new object [0];
while ((bool)moveNextMethod.Invoke(enumerator, empty_args))
{
currentValue = getCurrentMethod.Invoke(enumerator, empty_args);
key = CodeInterpreter.GetMember(genericDictionaryKeyProperty, currentValue);
value = CodeInterpreter.GetMember(genericDictionaryValueProperty, currentValue);
WriteStartElement(key, 0 /*nameIndex*/);
WriteValue(genericDictionaryValueProperty.PropertyType, value);
WriteEndElement();
}
}
else
{
WriteArrayAttribute();
var emptyArray = new object [0];
while (enumerator != null && enumerator.MoveNext())
{
currentValue = getCurrentMethod.Invoke(enumerator, emptyArray);
if (incrementCollectionCountMethod == null)
{
XmlFormatGeneratorStatics.IncrementItemCountMethod.Invoke(context, new object [] { 1 });
}
if (!TryWritePrimitive(elementType, () => currentValue, null, null, itemName, 0))
{
WriteStartElement(itemName, 0);
if (isGenericDictionary || isDictionary)
{
var jc = JsonDataContract.GetJsonDataContract(XmlObjectSerializerWriteContextComplexJson.GetRevisedItemContract(
collectionDataContract.ItemContract));
// FIXME: this TypeHandle might be wrong; there is no easy way to get Type for currentValue though.
DataContractJsonSerializer.WriteJsonValue(jc, writer, currentValue, context, currentValue.GetType().TypeHandle);
}
else
{
WriteValue(elementType, currentValue);
}
WriteEndElement();
}
}
}
}
}
