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; } } }