private static void AddDictionaryEntryData(DataContractJsonSerializer serializer, Dictionary <string, object> currentEntry, string key, Type declaredType, object value, XmlObjectSerializerWriteContextComplexJson context)
{
if (value == null)
{
currentEntry[key] = value;
return;
}
Type runtimeType = value.GetType();
if (IsTypePrimitive(runtimeType))
{
currentEntry[key] = value;
}
else
{
if (declaredType.GetTypeInfo().IsGenericType&& declaredType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
{
declaredType = Nullable.GetUnderlyingType(declaredType);
}
DataContract runtimeDataContract = DataContract.GetDataContract(runtimeType);
if (declaredType != runtimeType)
{
context.VerifyType(runtimeDataContract);
}
currentEntry[key] = serializer.ConvertDataContractToObject(value, runtimeDataContract, context, EmitTypeInformation(runtimeDataContract, runtimeType), runtimeDataContract.UnderlyingType.TypeHandle);
}
}
public static IEnumerable ConvertGenericListToArray(DataContractJsonSerializer serializer, IEnumerable value, CollectionDataContract dataContract, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType)
{
Type listArgumentType = dataContract.ItemType;
if (listArgumentType.GetTypeInfo().IsGenericType)
{
listArgumentType = listArgumentType.GetGenericArguments()[0];
}
List <object> serializedList = new List <object>();
MethodInfo getEnumeratorMethod = dataContract.GetEnumeratorMethod;
IEnumerator enumerator = (getEnumeratorMethod == null) ? value.GetEnumerator() : (IEnumerator)getEnumeratorMethod.Invoke(value, Globals.EmptyTypeArray);
while (enumerator.MoveNext())
{
if (enumerator.Current == null || enumerator.Current.GetType().GetTypeInfo().IsPrimitive)
{
serializedList.Add(enumerator.Current);
}
else
{
Type currentItemType = enumerator.Current.GetType();
DataContract currentItemDataContract = DataContract.GetDataContract(currentItemType);
bool emitTypeInformation = EmitTypeInformation(dataContract.ItemContract, currentItemType);
if (writeServerType || emitTypeInformation)
{
context.CheckIfTypeNeedsVerifcation(dataContract.ItemContract, currentItemDataContract);
}
context.PushKnownTypes(dataContract);
serializedList.Add(serializer.ConvertDataContractToObject(enumerator.Current, currentItemDataContract, context, (writeServerType || emitTypeInformation), dataContract.ItemType.TypeHandle));
context.PopKnownTypes(dataContract);
}
}
return(serializedList);
}
public static List <object> ConvertGenericDictionaryToArray(DataContractJsonSerializer serializer, IEnumerable value, CollectionDataContract dataContract, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType)
{
List <object> keyValuePair = new List <object>();
Dictionary <string, object> currentEntry;
Type[] declaredTypes = dataContract.ItemType.GetGenericArguments();
MethodInfo getEnumeratorMethod = dataContract.GetEnumeratorMethod;
IDictionaryEnumerator enumerator = (IDictionaryEnumerator)((getEnumeratorMethod == null) ? value.GetEnumerator() : (IDictionaryEnumerator)getEnumeratorMethod.Invoke(value, Globals.EmptyTypeArray));
while (enumerator.MoveNext())
{
DictionaryEntry current = enumerator.Entry;
DataContract currentDataContract = DataContract.GetDataContract(enumerator.Current.GetType());
currentEntry = new Dictionary <string, object>();
if (writeServerType)
{
AddTypeInformation(currentEntry, currentDataContract);
}
context.PushKnownTypes(dataContract);
AddDictionaryEntryData(serializer, currentEntry, writeServerType ? JsonGlobals.KeyString.ToLowerInvariant() : JsonGlobals.KeyString, declaredTypes[0], current.Key, context);
AddDictionaryEntryData(serializer, currentEntry, writeServerType ? JsonGlobals.ValueString.ToLowerInvariant() : JsonGlobals.ValueString, declaredTypes[1], current.Value, context);
keyValuePair.Add(currentEntry);
context.PopKnownTypes(dataContract);
}
return(keyValuePair);
}
public static Dictionary <string, object> ConvertClassDataContractToDictionary(DataContractJsonSerializer serializer, ClassDataContract dataContract, object value, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType)
{
Dictionary <string, object> classToDictionary = new Dictionary <string, object>();
if (writeServerType)
{
AddTypeInformation(classToDictionary, DataContract.GetDataContract(value.GetType()));
}
if (dataContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
{
DateTimeOffset dto = (DateTimeOffset)value;
classToDictionary["DateTime"] = dto.UtcDateTime;
classToDictionary["OffsetMinutes"] = (short)dto.Offset.TotalMinutes;
return(classToDictionary);
}
else if (dataContract.IsKeyValuePairAdapter)
{
//Convert KeyValuePair<K,T> to KeyValuePairAdapter<K,T>
value = dataContract.KeyValuePairAdapterConstructorInfo.Invoke(new object[] { value });
}
DataContractJsonSerializer.InvokeOnSerializing(value, dataContract, context);
WriteClassDataContractMembers(serializer, dataContract, ref classToDictionary, value, context);
DataContractJsonSerializer.InvokeOnSerialized(value, dataContract, context);
return(classToDictionary);
}
private static void WriteClassDataContractMembers(DataContractJsonSerializer serializer, ClassDataContract dataContract, ref Dictionary <string, object> classToDictionary, object value, XmlObjectSerializerWriteContextComplexJson context)
{
if (dataContract.BaseContract != null)
{
WriteClassDataContractMembers(serializer, dataContract.BaseContract, ref classToDictionary, value, context);
}
for (int i = 0; i < dataContract.Members.Count; i++)
{
DataMember member = dataContract.Members[i];
object memberValue = GetMemberValue(value, dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
string memberName = System.Xml.XmlConvert.DecodeName(member.Name);
if (classToDictionary.ContainsKey(memberName))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.JsonDuplicateMemberNames,
DataContract.GetClrTypeFullName(dataContract.UnderlyingType), memberName)));
}
if (!member.EmitDefaultValue)
{
//Dont emit value if its null or default(valuetype)
if (memberValue == null || (member.MemberTypeContract.IsValueType && object.Equals(memberValue, Activator.CreateInstance(member.MemberType))))
{
continue;
}
}
if (memberValue == null || IsTypePrimitive(member.MemberType))
{
classToDictionary[memberName] = memberValue;
}
else
{
Type memberValueType = memberValue.GetType();
if (member.MemberType == memberValueType ||
//Special case Nullable<DateTimeOffset> and Nullable<Struct>
(member.IsNullable && !EmitTypeInformation(member.MemberTypeContract, memberValueType)))
{
classToDictionary[memberName] = serializer.ConvertDataContractToObject(memberValue, member.MemberTypeContract, context, false, member.MemberTypeContract.UnderlyingType.TypeHandle);
}
else
{
//Push KnownTypes of this DataContract
context.PushKnownTypes(dataContract);
DataContract memberValueContract = DataContract.GetDataContract(memberValue.GetType());
if (member.MemberType.GetTypeInfo().IsInterface)
{
XmlObjectSerializerWriteContextComplexJson.VerifyObjectCompatibilityWithInterface(memberValueContract, memberValue, member.MemberType);
}
context.CheckIfTypeNeedsVerifcation(member.MemberTypeContract, memberValueContract);
classToDictionary[memberName] = serializer.ConvertDataContractToObject(memberValue, memberValueContract, context, true, member.MemberTypeContract.UnderlyingType.TypeHandle);
context.PopKnownTypes(dataContract);
}
}
}
}
public static Dictionary <DataContract, List <RefData> > GetReferenceCounts(object data, ref Dictionary <DataContract, List <RefData> > nonRefdValues)
{
Dictionary <DataContract, List <RefData> > alreadyRefdValues = new Dictionary <DataContract, List <RefData> >();
Type type = data.GetType();
DataContract dataContract = DataContract.GetDataContract(type, supportCollectionDataContract);
s_refStack.Clear();
FindAndAddRefd(data, dataContract, ref alreadyRefdValues, ref nonRefdValues);
return(alreadyRefdValues);
}
internal static DataContract?GetRevisedItemContract(DataContract oldItemContract)
{
if ((oldItemContract != null) &&
oldItemContract.UnderlyingType.IsGenericType &&
(oldItemContract.UnderlyingType.GetGenericTypeDefinition() == Globals.TypeOfKeyValue))
{
return(DataContract.GetDataContract(oldItemContract.UnderlyingType));
}
return(oldItemContract);
}
internal static DataContract GetDataContract(DataContract declaredTypeContract, Type declaredType, Type objectType)
{
if (declaredType.IsInterface && CollectionDataContract.IsCollectionInterface(declaredType))
{
return(declaredTypeContract);
}
else if (declaredType.IsArray)//Array covariance is not supported in XSD
{
return(declaredTypeContract);
}
else
{
return(DataContract.GetDataContract(objectType.TypeHandle, objectType, SerializationMode.SharedContract));
}
}
private static void ReadClassDataContractMembers(DataContractJsonSerializer serializer, ClassDataContract dataContract, Dictionary <string, object> deserialzedValue, object newInstance, XmlObjectSerializerReadContextComplexJson context)
{
if (dataContract.BaseContract != null)
{
ReadClassDataContractMembers(serializer, dataContract.BaseContract, deserialzedValue, newInstance, context);
}
for (int i = 0; i < dataContract.Members.Count; i++)
{
DataMember member = dataContract.Members[i];
object currentMemberValue;
if (deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name), out currentMemberValue) ||
dataContract.IsKeyValuePairAdapter && deserialzedValue.TryGetValue(XmlConvert.DecodeName(dataContract.Members[i].Name.ToLowerInvariant()), out currentMemberValue))
{
if (member.MemberType.GetTypeInfo().IsPrimitive || currentMemberValue == null)
{
SetMemberValue(newInstance, serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context), dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
}
else
{
context.PushKnownTypes(dataContract);
object subMemberValue = serializer.ConvertObjectToDataContract(member.MemberTypeContract, currentMemberValue, context);
Type declaredType = (member.MemberType.GetTypeInfo().IsGenericType&& member.MemberType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
? Nullable.GetUnderlyingType(member.MemberType)
: member.MemberType;
if (!(declaredType == Globals.TypeOfObject && subMemberValue.GetType() == Globals.TypeOfObjectArray) && declaredType != subMemberValue.GetType())
{
DataContract memberValueContract = DataContract.GetDataContract(subMemberValue.GetType());
context.CheckIfTypeNeedsVerifcation(member.MemberTypeContract, memberValueContract);
}
if (member.IsGetOnlyCollection)
{
PopulateReadOnlyCollection(newInstance, member, (IEnumerable)subMemberValue);
}
else
{
SetMemberValue(newInstance, subMemberValue, dataContract.Members[i].MemberInfo, dataContract.UnderlyingType);
}
context.PopKnownTypes(dataContract);
}
}
else if (member.IsRequired)
{
XmlObjectSerializerWriteContext.ThrowRequiredMemberMustBeEmitted(dataContract.MemberNames[i].Value, dataContract.UnderlyingType);
}
}
}
public override object ReadJsonValueCore(XmlReaderDelegator jsonReader, XmlObjectSerializerReadContextComplexJson context)
{
object obj;
string contentMode = jsonReader.GetAttribute(JsonGlobals.typeString);
switch (contentMode)
{
case JsonGlobals.nullString:
jsonReader.Skip();
obj = null;
break;
case JsonGlobals.booleanString:
obj = jsonReader.ReadElementContentAsBoolean();
break;
case JsonGlobals.stringString:
case null:
obj = jsonReader.ReadElementContentAsString();
break;
case JsonGlobals.numberString:
obj = ParseJsonNumber(jsonReader.ReadElementContentAsString());
break;
case JsonGlobals.objectString:
jsonReader.Skip();
obj = new object();
break;
case JsonGlobals.arrayString:
// Read as object array
return(DataContractJsonSerializer.ReadJsonValue(DataContract.GetDataContract(Globals.TypeOfObjectArray), jsonReader, context));
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.JsonUnexpectedAttributeValue, contentMode)));
}
if (context != null)
{
context.AddNewObject(obj);
}
return(obj);
}
private void AddCollectionItemContractsToKnownDataContracts(DataContract traditionalDataContract)
{
if (traditionalDataContract.KnownDataContracts != null)
{
foreach (KeyValuePair <XmlQualifiedName, DataContract> knownDataContract in traditionalDataContract.KnownDataContracts)
{
if (!object.ReferenceEquals(knownDataContract, null))
{
CollectionDataContract collectionDataContract = knownDataContract.Value as CollectionDataContract;
while (collectionDataContract != null)
{
DataContract itemContract = collectionDataContract.ItemContract;
if (knownDataContracts == null)
{
knownDataContracts = new Dictionary <XmlQualifiedName, DataContract>();
}
if (!knownDataContracts.ContainsKey(itemContract.StableName))
{
knownDataContracts.Add(itemContract.StableName, itemContract);
}
if (collectionDataContract.ItemType.GetTypeInfo().IsGenericType &&
collectionDataContract.ItemType.GetGenericTypeDefinition() == typeof(KeyValue <,>))
{
DataContract itemDataContract = DataContract.GetDataContract(Globals.TypeOfKeyValuePair.MakeGenericType(collectionDataContract.ItemType.GetGenericArguments()));
if (!knownDataContracts.ContainsKey(itemDataContract.StableName))
{
knownDataContracts.Add(itemDataContract.StableName, itemDataContract);
}
}
if (!(itemContract is CollectionDataContract))
{
break;
}
collectionDataContract = itemContract as CollectionDataContract;
}
}
}
}
}
private DataContractJsonSerializer CreateDefaultSerializer(Type type)
{
Fx.Assert(type != null, "type cannot be null.");
DataContractJsonSerializer serializer = null;
try
{
//// TODO: CSDMAIN 211321 -- determine the correct algorithm to know what is serializable.
DataContract.GetDataContract(type);
serializer = IsKnownUnserializableType(type) ? null : new DataContractJsonSerializer(type);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
}
return(serializer);
}
private static void FindRefHandleMembers(object data, DataContract dataContract, ref Dictionary <DataContract, List <RefData> > alreadyRefdValues, ref Dictionary <DataContract, List <RefData> > nonRefdValues)
{
if (dataContract is ClassDataContract)
{
ClassDataContract classContract = dataContract as ClassDataContract;
foreach (DataMember member in classContract.Members)
{
object memberData = member.GetMemberValue(data);
if (memberData != null)
{
FindAndAddRefd(memberData, DataContract.GetDataContract(memberData.GetType(), supportCollectionDataContract), ref alreadyRefdValues, ref nonRefdValues);
}
}
}
else if (dataContract is ArrayDataContract)
{
ArrayDataContract arrayContract = dataContract as ArrayDataContract;
foreach (object obj in (IEnumerable)data)
{
if (obj != null)
{
FindAndAddRefd(obj, DataContract.GetDataContract(obj.GetType(), supportCollectionDataContract), ref alreadyRefdValues, ref nonRefdValues);
}
}
}
else if (dataContract is CollectionDataContract)
{
FindRefHandleCollectionDataContractMembers(data, dataContract, ref alreadyRefdValues, ref nonRefdValues);
}
else if (dataContract is EnumDataContract || dataContract is PrimitiveDataContract)
{
//Nothing to do
}
else
{
throw new Exception("TestDriver Exception: Type Not Supported");
}
}
private void InitArgs(Type objType)
{
_xmlWriterArg = _ilg.GetArg(0);
_contextArg = _ilg.GetArg(2);
_dataContractArg = _ilg.GetArg(3);
_objectLocal = _ilg.DeclareLocal(objType, "objSerialized");
ArgBuilder objectArg = _ilg.GetArg(1);
_ilg.Load(objectArg);
// Copy the data from the DataTimeOffset object passed in to the DateTimeOffsetAdapter.
// DateTimeOffsetAdapter is used here for serialization purposes to bypass the ISerializable implementation
// on DateTimeOffset; which does not work in partial trust.
if (objType == Globals.TypeOfDateTimeOffsetAdapter)
{
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfDateTimeOffset);
_ilg.Call(XmlFormatGeneratorStatics.GetDateTimeOffsetAdapterMethod);
}
else if (objType == Globals.TypeOfMemoryStreamAdapter)
{
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfMemoryStream);
_ilg.Call(XmlFormatGeneratorStatics.GetMemoryStreamAdapterMethod);
}
//Copy the KeyValuePair<K,T> to a KeyValuePairAdapter<K,T>.
else if (objType.IsGenericType && objType.GetGenericTypeDefinition() == Globals.TypeOfKeyValuePairAdapter)
{
ClassDataContract dc = (ClassDataContract)DataContract.GetDataContract(objType);
_ilg.ConvertValue(objectArg.ArgType, Globals.TypeOfKeyValuePair.MakeGenericType(dc.KeyValuePairGenericArguments !));
_ilg.New(dc.KeyValuePairAdapterConstructorInfo !);
}
else
{
_ilg.ConvertValue(objectArg.ArgType, objType);
}
_ilg.Stloc(_objectLocal);
}
private void AddCollectionItemContractsToKnownDataContracts()
{
if (this.traditionalDataContract.KnownDataContracts != null)
{
foreach (KeyValuePair <XmlQualifiedName, DataContract> pair in this.traditionalDataContract.KnownDataContracts)
{
if (!object.ReferenceEquals(pair, null))
{
DataContract itemContract;
for (CollectionDataContract contract = pair.Value as CollectionDataContract; contract != null; contract = itemContract as CollectionDataContract)
{
itemContract = contract.ItemContract;
if (this.knownDataContracts == null)
{
this.knownDataContracts = new Dictionary <XmlQualifiedName, DataContract>();
}
if (!this.knownDataContracts.ContainsKey(itemContract.StableName))
{
this.knownDataContracts.Add(itemContract.StableName, itemContract);
}
if (contract.ItemType.IsGenericType && (contract.ItemType.GetGenericTypeDefinition() == typeof(KeyValue <,>)))
{
DataContract dataContract = DataContract.GetDataContract(Globals.TypeOfKeyValuePair.MakeGenericType(contract.ItemType.GetGenericArguments()));
if (!this.knownDataContracts.ContainsKey(dataContract.StableName))
{
this.knownDataContracts.Add(dataContract.StableName, dataContract);
}
}
if (!(itemContract is CollectionDataContract))
{
break;
}
}
}
}
}
}
private object ConvertObjectToPrimitiveDataContract(DataContract contract, object value, XmlObjectSerializerReadContextComplexJson context)
{
// Taking the right deserialized value for datetime string based on contract information
var tuple = value as Tuple <DateTime, string>;
if (tuple != null)
{
if (contract is StringDataContract || contract.UnderlyingType == typeof(object))
{
value = tuple.Item2;
}
else
{
value = tuple.Item1;
}
}
if (contract is TimeSpanDataContract)
{
return(XmlConvert.ToTimeSpan(String.Format(CultureInfo.InvariantCulture, "{0}", value)));
}
else if (contract is ByteArrayDataContract)
{
return(ObjectToDataContractConverter.ConvertToArray(typeof(Byte), (IList)value));
}
else if (contract is GuidDataContract)
{
return(new Guid(String.Format(CultureInfo.InvariantCulture, "{0}", value)));
}
else if (contract is ObjectDataContract)
{
if (value is ICollection)
{
return(ConvertObjectToDataContract(DataContract.GetDataContract(Globals.TypeOfObjectArray), value, context));
}
return(TryParseJsonNumber(value));
}
else if (contract is QNameDataContract)
{
return(XmlObjectSerializerReadContextComplexJson.ParseQualifiedName(value.ToString()));
}
else if (contract is StringDataContract)
{
if (value is bool)
{
return(((bool)value) ? Globals.True : Globals.False);
}
return(value.ToString());
}
else if (contract is UriDataContract)
{
return(new Uri(value.ToString(), UriKind.RelativeOrAbsolute));
}
else if (contract is DoubleDataContract)
{
if (value is float)
{
return((double)(float)value);
}
if (value is double)
{
return((double)value);
}
return(double.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, CultureInfo.InvariantCulture));
}
else if (contract is DecimalDataContract)
{
return(decimal.Parse(String.Format(CultureInfo.InvariantCulture, "{0}", value), NumberStyles.Float, CultureInfo.InvariantCulture));
}
return(Convert.ChangeType(value, contract.UnderlyingType, CultureInfo.InvariantCulture));
}
internal object ConvertDataContractToObject(object value, DataContract contract, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType, RuntimeTypeHandle declaredTypeHandle)
{
if (context != null)
{
context.OnHandleReference(null /*XmlWriter*/, value, true); // canContainReferences
}
try
{
if (contract is ObjectDataContract)
{
Type valueType = value.GetType();
if (valueType != Globals.TypeOfObject)
{
return(ConvertDataContractToObject(value, DataContract.GetDataContract(valueType), context, true, contract.UnderlyingType.TypeHandle));
}
else
{
return(value);
}
}
else if (contract is TimeSpanDataContract)
{
return(XmlConvert.ToString((TimeSpan)value));
}
else if (contract is QNameDataContract)
{
XmlQualifiedName qname = (XmlQualifiedName)value;
return((qname.IsEmpty) ? string.Empty : (qname.Name + ":" + qname.Namespace));
}
else if (contract is PrimitiveDataContract)
{
return(value);
}
else if (contract is CollectionDataContract)
{
CollectionDataContract collectionContract = contract as CollectionDataContract;
switch (collectionContract.Kind)
{
case CollectionKind.GenericDictionary:
case CollectionKind.Dictionary:
return(DataContractToObjectConverter.ConvertGenericDictionaryToArray(this, (IEnumerable)value, collectionContract, context, writeServerType));
default:
return(DataContractToObjectConverter.ConvertGenericListToArray(this, (IEnumerable)value, collectionContract, context, writeServerType));
}
}
else if (contract is ClassDataContract)
{
ClassDataContract classContract = contract as ClassDataContract;
if (Globals.TypeOfScriptObject_IsAssignableFrom(classContract.UnderlyingType))
{
return(ConvertScriptObjectToObject(value));
}
return(DataContractToObjectConverter.ConvertClassDataContractToDictionary(this, (ClassDataContract)contract, value, context, writeServerType));
}
else if (contract is EnumDataContract)
{
if (((EnumDataContract)contract).IsULong)
{
return(Convert.ToUInt64(value, null));
}
else
{
return(Convert.ToInt64(value, null));
}
}
else if (contract is XmlDataContract)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(Type.GetTypeFromHandle(declaredTypeHandle), GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList));
MemoryStream memoryStream = new MemoryStream();
dataContractSerializer.WriteObject(memoryStream, value);
memoryStream.Position = 0;
return(new StreamReader(memoryStream, Encoding.UTF8).ReadToEnd());
}
}
finally
{
if (context != null)
{
context.OnEndHandleReference(null /*XmlWriter*/, value, true); // canContainReferences
}
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.UnknownDataContract, contract.Name)));
}
protected override void WriteDataContractValue(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle declaredTypeHandle)
{
_jsonSerializer.WriteObjectInternal(obj, dataContract, this, WriteTypeInfo(null, dataContract, DataContract.GetDataContract(declaredTypeHandle, obj.GetType())), declaredTypeHandle);
}
private static object ConvertDictionary(DataContractJsonSerializer serializer, DataContract contract, object obj, XmlObjectSerializerReadContextComplexJson context)
{
System.Diagnostics.Debug.Assert(obj is IDictionary, "obj is IDictionary");
Dictionary <string, object> dictOfStringObject = obj as Dictionary <string, object>;
if (dictOfStringObject.ContainsKey(JsonGlobals.ServerTypeString))
{
return(ConvertDictionaryToClassDataContract(serializer,
ResolveDataContractFromTypeInformation(dictOfStringObject[JsonGlobals.ServerTypeString].ToString(), null, context),
dictOfStringObject, context));
}
else if (dictOfStringObject.ContainsKey("DateTime") && dictOfStringObject.ContainsKey("OffsetMinutes"))
{
return(ConvertDictionaryToClassDataContract(serializer, (ClassDataContract)DataContract.GetDataContract(typeof(DateTimeOffset)), dictOfStringObject, context));
}
else
{
//Its either an empty object "{}" or a weakly typed Json Object such as {"a",1;"b";2} which we dont support reading in Orcas
return(new Object());
}
}
private static void FindRefHandleCollectionDataContractMembers(object data, DataContract dataContract, ref Dictionary <DataContract, List <RefData> > alreadyRefdValues, ref Dictionary <DataContract, List <RefData> > nonRefdValues)
{
CollectionDataContract collectionContract = dataContract as CollectionDataContract;
if (!collectionContract.IsDictionary)
{
foreach (object obj in (IEnumerable)data)
{
if (obj != null)
{
FindAndAddRefd(obj, DataContract.GetDataContract(obj.GetType(), supportCollectionDataContract), ref alreadyRefdValues, ref nonRefdValues);
}
}
}
else
{
IDictionary dictionary = data as IDictionary;
if (dictionary != null)
{
foreach (object key in dictionary.Keys)
{
if (key != null)
{
FindAndAddRefd(key, DataContract.GetDataContract(key.GetType(), supportCollectionDataContract), ref alreadyRefdValues, ref nonRefdValues);
}
}
foreach (object value in dictionary.Values)
{
if (value != null)
{
FindAndAddRefd(value, DataContract.GetDataContract(value.GetType(), supportCollectionDataContract), ref alreadyRefdValues, ref nonRefdValues);
}
}
}
else
{
if (collectionContract.GetEnumeratorMethod != null)
{
object dictEnumObj = null;
try
{
dictEnumObj = collectionContract.GetEnumeratorMethod.Invoke(data, new object[] { });
}
catch (Exception) { }
IDictionaryEnumerator dictEnum = dictEnumObj as IDictionaryEnumerator;
if (dictEnum != null)
{
while (dictEnum.MoveNext())
{
FindAndAddRefd(dictEnum.Key, DataContract.GetDataContract(dictEnum.Key.GetType(), supportCollectionDataContract), ref alreadyRefdValues, ref nonRefdValues);
}
dictEnum.Reset();
while (dictEnum.MoveNext())
{
if (dictEnum.Value != null)
{
FindAndAddRefd(dictEnum.Value, DataContract.GetDataContract(dictEnum.Value.GetType(), supportCollectionDataContract), ref alreadyRefdValues, ref nonRefdValues);
}
}
}
}
else
{
throw new Exception("TestDriver Exception: Dictionary CollectionDataCotnract Type Not Supported");
}
}
}
}
protected override void WriteDataContractValue(DataContract dataContract, XmlWriterDelegator xmlWriter, object obj, RuntimeTypeHandle declaredTypeHandle)
{
#if NET_NATIVE || MERGE_DCJS
JsonDataContract jsonDataContract = JsonDataContract.GetJsonDataContract(dataContract);
if (_emitXsiType == EmitTypeInformation.Always && !_perCallXsiTypeAlreadyEmitted && RequiresJsonTypeInfo(dataContract))
{
WriteTypeInfo(xmlWriter, jsonDataContract.TypeName);
}
_perCallXsiTypeAlreadyEmitted = false;
DataContractJsonSerializerImpl.WriteJsonValue(jsonDataContract, xmlWriter, obj, this, declaredTypeHandle);
#else
_jsonSerializer.WriteObjectInternal(obj, dataContract, this, WriteTypeInfo(null, dataContract, DataContract.GetDataContract(declaredTypeHandle, obj.GetType())), declaredTypeHandle);
#endif
}
internal MessageHelpInformation(OperationDescription od, bool isRequest, Type type, bool wrapped)
{
this.Type = type;
this.SupportsJson = WebHttpBehavior.SupportsJsonFormat(od);
string direction = isRequest ? SR2.GetString(SR2.HelpPageRequest) : SR2.GetString(SR2.HelpPageResponse);
if (wrapped && !typeof(void).Equals(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageBodyIsWrapped, direction);
this.FormatString = SR2.GetString(SR2.HelpPageUnknown);
}
else if (typeof(void).Equals(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageBodyIsEmpty, direction);
this.FormatString = SR2.GetString(SR2.HelpPageNA);
}
else if (typeof(Message).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsMessage, direction);
this.FormatString = SR2.GetString(SR2.HelpPageUnknown);
}
else if (typeof(Stream).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsStream, direction);
this.FormatString = SR2.GetString(SR2.HelpPageUnknown);
}
else if (typeof(Atom10FeedFormatter).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsAtom10Feed, direction);
this.FormatString = WebMessageFormat.Xml.ToString();
}
else if (typeof(Atom10ItemFormatter).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsAtom10Entry, direction);
this.FormatString = WebMessageFormat.Xml.ToString();
}
else if (typeof(AtomPub10ServiceDocumentFormatter).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsAtomPubServiceDocument, direction);
this.FormatString = WebMessageFormat.Xml.ToString();
}
else if (typeof(AtomPub10CategoriesDocumentFormatter).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsAtomPubCategoriesDocument, direction);
this.FormatString = WebMessageFormat.Xml.ToString();
}
else if (typeof(Rss20FeedFormatter).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsRSS20Feed, direction);
this.FormatString = WebMessageFormat.Xml.ToString();
}
else if (typeof(SyndicationFeedFormatter).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsSyndication, direction);
this.FormatString = WebMessageFormat.Xml.ToString();
}
else if (typeof(XElement).IsAssignableFrom(type) || typeof(XmlElement).IsAssignableFrom(type))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageIsXML, direction);
this.FormatString = WebMessageFormat.Xml.ToString();
}
else
{
try
{
bool usesXmlSerializer = od.Behaviors.Contains(typeof(XmlSerializerOperationBehavior));
XmlQualifiedName name;
this.SchemaSet = new XmlSchemaSet();
IDictionary <XmlQualifiedName, Type> knownTypes = new Dictionary <XmlQualifiedName, Type>();
if (usesXmlSerializer)
{
XmlReflectionImporter importer = new XmlReflectionImporter();
XmlTypeMapping typeMapping = importer.ImportTypeMapping(this.Type);
name = new XmlQualifiedName(typeMapping.ElementName, typeMapping.Namespace);
XmlSchemas schemas = new XmlSchemas();
XmlSchemaExporter exporter = new XmlSchemaExporter(schemas);
exporter.ExportTypeMapping(typeMapping);
foreach (XmlSchema schema in schemas)
{
this.SchemaSet.Add(schema);
}
}
else
{
XsdDataContractExporter exporter = new XsdDataContractExporter();
List <Type> listTypes = new List <Type>(od.KnownTypes);
bool isQueryable;
Type dataContractType = DataContractSerializerOperationFormatter.GetSubstituteDataContractType(this.Type, out isQueryable);
listTypes.Add(dataContractType);
exporter.Export(listTypes);
if (!exporter.CanExport(dataContractType))
{
this.BodyDescription = SR2.GetString(SR2.HelpPageCouldNotGenerateSchema);
this.FormatString = SR2.GetString(SR2.HelpPageUnknown);
return;
}
name = exporter.GetRootElementName(dataContractType);
DataContract typeDataContract = DataContract.GetDataContract(dataContractType);
if (typeDataContract.KnownDataContracts != null)
{
foreach (XmlQualifiedName dataContractName in typeDataContract.KnownDataContracts.Keys)
{
knownTypes.Add(dataContractName, typeDataContract.KnownDataContracts[dataContractName].UnderlyingType);
}
}
foreach (Type knownType in od.KnownTypes)
{
XmlQualifiedName knownTypeName = exporter.GetSchemaTypeName(knownType);
if (!knownTypes.ContainsKey(knownTypeName))
{
knownTypes.Add(knownTypeName, knownType);
}
}
foreach (XmlSchema schema in exporter.Schemas.Schemas())
{
this.SchemaSet.Add(schema);
}
}
this.SchemaSet.Compile();
XmlWriterSettings settings = new XmlWriterSettings
{
CloseOutput = false,
Indent = true,
};
if (this.SupportsJson)
{
XDocument exampleDocument = new XDocument();
using (XmlWriter writer = XmlWriter.Create(exampleDocument.CreateWriter(), settings))
{
HelpExampleGenerator.GenerateJsonSample(this.SchemaSet, name, writer, knownTypes);
}
this.JsonExample = exampleDocument.Root;
}
if (name.Namespace != "http://schemas.microsoft.com/2003/10/Serialization/")
{
foreach (XmlSchema schema in this.SchemaSet.Schemas(name.Namespace))
{
this.Schema = schema;
}
}
XDocument XmlExampleDocument = new XDocument();
using (XmlWriter writer = XmlWriter.Create(XmlExampleDocument.CreateWriter(), settings))
{
HelpExampleGenerator.GenerateXmlSample(this.SchemaSet, name, writer);
}
this.XmlExample = XmlExampleDocument.Root;
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.BodyDescription = SR2.GetString(SR2.HelpPageCouldNotGenerateSchema);
this.FormatString = SR2.GetString(SR2.HelpPageUnknown);
this.Schema = null;
this.JsonExample = null;
this.XmlExample = null;
}
}
}