/// <summary> /// Reads a Fault reply from the service. /// </summary> /// <param name="reader">The reader, which should start at the "Fault" element.</param> /// <param name="operationName">Name of the operation.</param> /// <returns>A FaultException with the details in the server reply</returns> private static FaultException <DomainServiceFault> ReadFaultException(System.Xml.XmlDictionaryReader reader, string operationName) { FaultCode faultCode; FaultReason faultReason; List <FaultReasonText> faultReasons = new List <FaultReasonText>(); reader.ReadStartElement("Fault"); // <Fault> reader.ReadStartElement("Code"); // <Code> reader.ReadStartElement("Value"); // <Value> faultCode = new FaultCode(reader.ReadContentAsString()); reader.ReadEndElement(); // </Value> reader.ReadEndElement(); // </Code> reader.ReadStartElement("Reason"); while (reader.LocalName == "Text") { var lang = reader.XmlLang; reader.ReadStartElement("Text"); var text = reader.ReadContentAsString(); reader.ReadEndElement(); faultReasons.Add(new FaultReasonText(text, lang)); } reader.ReadEndElement(); // </Reason> faultReason = new FaultReason(faultReasons); reader.ReadStartElement("Detail"); // <Detail> var fault = (DomainServiceFault)s_faultSerializer.ReadObject(reader); return(new FaultException <DomainServiceFault>(fault, faultReason, faultCode, operationName)); }
public void test_serialization() { Note n1 = new Note("Some current note", Guid.NewGuid()), n2 = new Note("Some former note", Guid.NewGuid()); NoteDomain foo = new NoteDomain(), bar; foo.add_note(n1); Guid rem_guid = foo.add_note(n2); foo.remove_note(rem_guid); DataContractSerializer fmt = new DataContractSerializer(typeof(NoteDomain)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (NoteDomain)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.notes.Count, bar.notes.Count); foreach (Guid note in foo.notes.Keys) { Assert.IsTrue(bar.notes.ContainsKey(note)); Assert.AreEqual(foo.notes[note].contents, bar.notes[note].contents); } Assert.AreEqual(foo.active_notes.Count, bar.active_notes.Count); foreach (Guid note in foo.active_notes) { Assert.IsTrue(bar.active_notes.Contains(note)); } }
public void test_serialization() { Character somebody = new Character("Somebody"); ActionCharacterSet action = new ActionCharacterSet(Guid.NewGuid(), null, somebody); Entry foo = new Entry(42, DateTime.Now, "Somebody joined the party", 3, guid: Guid.NewGuid()), bar; foo.actions.Add(action); DataContractSerializer fmt = new DataContractSerializer(typeof(Entry)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (Entry)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.timestamp, bar.timestamp); Assert.AreEqual(foo.created, bar.created); Assert.AreEqual(foo.description, bar.description); Assert.AreEqual(foo.session, bar.session); Assert.AreEqual(foo.actions.Count, bar.actions.Count); for (int i = 0; i < foo.actions.Count; i++) { Assert.AreEqual(foo.actions[i].description, bar.actions[i].description); } Assert.AreEqual(foo.guid, bar.guid); }
public void test_serialization() { CalendarEvent e1 = new CalendarEvent(Guid.NewGuid(), 42, "Some current event"), e2 = new CalendarEvent(Guid.NewGuid(), 45, "Some former event"); CalendarEventDomain foo = new CalendarEventDomain(), bar; foo.add_event(e1); Guid rem_guid = foo.add_event(e2); foo.remove_event(rem_guid); DataContractSerializer fmt = new DataContractSerializer(typeof(CalendarEventDomain)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (CalendarEventDomain)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.events.Count, bar.events.Count); foreach (Guid evt in foo.events.Keys) { Assert.IsTrue(bar.events.ContainsKey(evt)); Assert.AreEqual(foo.events[evt].name, bar.events[evt].name); } Assert.AreEqual(foo.active_events.Count, bar.active_events.Count); foreach (Guid evt in foo.active_events) { Assert.IsTrue(bar.active_events.Contains(evt)); } }
public void test_serialization() { Character c1 = new Character("Somebody"), c2 = new Character("Mr. Boddy"); CharacterDomain foo = new CharacterDomain(), bar; foo.add_character(c1); Guid mr_boddy = foo.add_character(c2); foo.remove_character(mr_boddy); DataContractSerializer fmt = new DataContractSerializer(typeof(CharacterDomain)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (CharacterDomain)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.characters.Count, bar.characters.Count); foreach (Guid chr in foo.characters.Keys) { Assert.IsTrue(bar.characters.ContainsKey(chr)); Assert.AreEqual(foo.characters[chr].name, bar.characters[chr].name); } Assert.AreEqual(foo.active_characters.Count, bar.active_characters.Count); foreach (Guid chr in foo.active_characters) { Assert.IsTrue(bar.active_characters.Contains(chr)); } }
public void test_serialization() { RefcountSet <int> foo = new RefcountSet <int>() { 1, 2, 3 }, bar; foo.Add(3); DataContractSerializer fmt = new DataContractSerializer(typeof(RefcountSet <int>)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (RefcountSet <int>)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.Count, bar.Count); Assert.AreEqual(foo.contents.Count, bar.contents.Count); foreach (int i in foo.contents.Keys) { Assert.IsTrue(bar.contents.ContainsKey(i)); Assert.AreEqual(foo.contents[i], bar.contents[i]); } }
public void test_serialization() { string s1 = "Some current item", s2 = "Some former item"; BaseDomain <string> foo = new BaseDomain <string>(), bar; foo.add_item(s1); Guid rem_guid = foo.add_item(s2); foo.remove_item(rem_guid); DataContractSerializer fmt = new DataContractSerializer(typeof(BaseDomain <string>)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (BaseDomain <string>)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.items.Count, bar.items.Count); foreach (Guid item in foo.items.Keys) { Assert.IsTrue(bar.items.ContainsKey(item)); Assert.AreEqual(foo.items[item], bar.items[item]); } Assert.AreEqual(foo.active_items.Count, bar.active_items.Count); foreach (Guid item in foo.active_items) { Assert.IsTrue(bar.active_items.Contains(item)); } }
public void test_serialization() { Dictionary <Guid, int> adjust_topics = new Dictionary <Guid, int>() { [Guid.NewGuid()] = -2, [Guid.NewGuid()] = 1, }; ActionNoteUpdate foo = new ActionNoteUpdate(Guid.NewGuid(), "Old note", "New Note", adjust_topics), bar; DataContractSerializer fmt = new DataContractSerializer(typeof(ActionNoteUpdate)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (ActionNoteUpdate)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.guid, bar.guid); Assert.AreEqual(foo.contents_from, bar.contents_from); Assert.AreEqual(foo.contents_to, bar.contents_to); Assert.AreEqual(foo.adjust_topics.Count, bar.adjust_topics.Count); foreach (Guid topic in foo.adjust_topics.Keys) { Assert.IsTrue(bar.adjust_topics.ContainsKey(topic)); Assert.AreEqual(foo.adjust_topics[topic], bar.adjust_topics[topic]); } }
public T Load <T>(string path) { T obj; string json = File.ReadAllText(path, Encoding.UTF8); using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(json))) { System.Xml.XmlDictionaryReader xmlReader = null; try { using (xmlReader = JsonReaderWriterFactory.CreateJsonReader(ms, System.Xml.XmlDictionaryReaderQuotas.Max)) { var serializer = new DataContractJsonSerializer(typeof(T), SerializeSettings); obj = (T)serializer.ReadObject(xmlReader); } } finally { if (xmlReader != null) { GC.SuppressFinalize(xmlReader); xmlReader = null; } } } return(obj); }
public static void Write_v1(string path) { //使用較舊的物件來讀取Xml檔內的數據(較新的物件:多一個屬性) DataContractSerializer serializer = new DataContractSerializer(typeof(Person)); System.IO.FileStream fs = new System.IO.FileStream(path, System.IO.FileMode.Open); System.Xml.XmlDictionaryReader xmlrd = System.Xml.XmlDictionaryReader.CreateTextReader(fs, new System.Xml.XmlDictionaryReaderQuotas()); Console.WriteLine("Deserializing v2 data to v1 object. \n\n"); Person p1 = serializer.ReadObject(xmlrd, false) as Person;//從XmlDictionaryReader讀取資料流 //Person_v2 p2 = serializer.ReadObject(xmlrd, false) as Person_v2;//轉不回來較新的物件=>null Console.WriteLine("V1 data has only a Name field."); Console.WriteLine("But the v2 data is stored in the "); Console.WriteLine("ExtensionData property. \n\n"); Console.WriteLine("\t Name: {0} \n", p1.Name); fs.Close(); // 改變欄位值並覆寫回物件 // Change data in the object. p1.Name = "John"; Console.WriteLine("Changed the Name value to 'John' "); Console.Write("and reserializing the object to version 2 \n\n"); // Reserialize the object. fs = new System.IO.FileStream(path, System.IO.FileMode.Create); serializer.WriteObject(fs, p1); fs.Close(); }
public void test_serialization() { Task t1 = new Task(Guid.NewGuid(), "Some current task"), t2 = new Task(Guid.NewGuid(), "Some former task"); TaskDomain foo = new TaskDomain(), bar; foo.add_task(t1); Guid rem_guid = foo.add_task(t2); foo.remove_task(rem_guid); DataContractSerializer fmt = new DataContractSerializer(typeof(TaskDomain)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (TaskDomain)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.tasks.Count, bar.tasks.Count); foreach (Guid task in foo.tasks.Keys) { Assert.IsTrue(bar.tasks.ContainsKey(task)); Assert.AreEqual(foo.tasks[task].name, bar.tasks[task].name); } Assert.AreEqual(foo.active_tasks.Count, bar.active_tasks.Count); foreach (Guid task in foo.active_tasks) { Assert.IsTrue(bar.active_tasks.Contains(task)); } }
public static Message CreateMessage(MessageVersion version, string action, System.Xml.XmlDictionaryReader body) { Contract.Requires(version != null); Contract.Requires(body != null); Contract.Ensures(Contract.Result <System.ServiceModel.Channels.Message>() != null); return(default(Message)); }
public static Message CreateMessage(System.Xml.XmlDictionaryReader envelopeReader, int maxSizeOfHeaders, MessageVersion version) { Contract.Requires(envelopeReader != null); Contract.Requires(version != null); Contract.Ensures(Contract.Result <System.ServiceModel.Channels.Message>() != null); return(default(Message)); }
public static string GetNestedValue(DocumentMetadata doc, string path) { System.Xml.XmlDictionaryReader jsonReader = JsonReaderWriterFactory.CreateJsonReader( Encoding.UTF8.GetBytes(doc.ToString()), new System.Xml.XmlDictionaryReaderQuotas()); XElement root = XElement.Load(jsonReader); string value = root.XPathSelectElement("//" + path).Value; return(value); }
/// <summary> /// ReadObject is used to read and object from the reader. Deserialize will do the work. /// </summary> /// <param name="reader"></param> /// <param name="verifyObjectName"></param> /// <returns></returns> public override object ReadObject(System.Xml.XmlDictionaryReader reader, bool verifyObjectName) { object result = null; if (!verifyObjectName || this.IsStartObject(reader)) { result = privateSerializer.Deserialize(reader); } return(result); }
/// <summary> /// Verifies the reader is at node with LocalName equal to operationName + postfix. /// If the reader is at any other node, then a <see cref="DomainOperationException is thrown"/> /// </summary> /// <param name="reader">The reader.</param> /// <param name="operationName">Name of the operation.</param> /// <param name="postfix">The postfix.</param> /// <exception cref="OpenRiaServices.Client.DomainOperationException">If reader is not at the expected xml element</exception> private static void VerifyReaderIsAtNode(System.Xml.XmlDictionaryReader reader, string operationName, string postfix) { // localName should be operationName + postfix if (!(reader.LocalName.Length == operationName.Length + postfix.Length && reader.LocalName.StartsWith(operationName) && reader.LocalName.EndsWith(postfix))) { throw new DomainOperationException( string.Format(Resources.DomainClient_UnexpectedResultContent, operationName + postfix, reader.LocalName) , OperationErrorStatus.ServerError, 0, null); } }
private object DeserializeArrayXmlSerializer(System.Xml.XmlDictionaryReader xmlReader, Type parameterType, string parameterName, string parameterNs, ICustomAttributeProvider customAttributeProvider) { var xmlArrayAttributes = customAttributeProvider.GetCustomAttributes(typeof(XmlArrayItemAttribute), true); XmlArrayItemAttribute xmlArrayItemAttribute = xmlArrayAttributes.FirstOrDefault() as XmlArrayItemAttribute; var xmlElementAttributes = customAttributeProvider.GetCustomAttributes(typeof(XmlElementAttribute), true); XmlElementAttribute xmlElementAttribute = xmlElementAttributes.FirstOrDefault() as XmlElementAttribute; var isEmpty = xmlReader.IsEmptyElement; var hasContainerElement = xmlElementAttribute == null; if (hasContainerElement) { xmlReader.ReadStartElement(parameterName, parameterNs); } var elementType = parameterType.GetElementType(); var arrayItemName = xmlArrayItemAttribute?.ElementName ?? xmlElementAttribute?.ElementName ?? elementType.Name; if (xmlArrayItemAttribute?.ElementName == null && elementType.Namespace?.StartsWith("System") == true) { var compiler = new CSharpCodeProvider(); var type = new CodeTypeReference(elementType); arrayItemName = compiler.GetTypeOutput(type); } var deserializeMethod = typeof(XmlSerializerExtensions).GetGenericMethod(nameof(XmlSerializerExtensions.DeserializeArray), elementType); var arrayItemNamespace = xmlArrayItemAttribute?.Namespace ?? parameterNs; var serializer = CachedXmlSerializer.GetXmlSerializer(elementType, arrayItemName, arrayItemNamespace); object result = null; lock (serializer) { if (xmlReader.HasValue && elementType?.FullName == "System.Byte") { result = xmlReader.ReadContentAsBase64(); } else { result = deserializeMethod.Invoke(null, new object[] { serializer, arrayItemName, arrayItemNamespace, xmlReader }); } } if (!isEmpty && hasContainerElement) { xmlReader.ReadEndElement(); } return(result); }
public object DeserializeInputParameter( System.Xml.XmlDictionaryReader xmlReader, Type parameterType, string parameterName, string parameterNs, ICustomAttributeProvider customAttributeProvider, IEnumerable <Type> knownTypes = null) { // Advance past any whitespace. while (xmlReader.NodeType == System.Xml.XmlNodeType.Whitespace && xmlReader.Read()) { } if (xmlReader.IsStartElement(parameterName, parameterNs)) { xmlReader.MoveToStartElement(parameterName, parameterNs); if (xmlReader.IsStartElement(parameterName, parameterNs)) { switch (_serializer) { case SoapSerializer.XmlSerializer: if (!parameterType.IsArray) { // case [XmlElement("parameter")] int parameter // case [XmlArray("parameter")] int[] parameter return(DeserializeObject(xmlReader, parameterType, parameterName, parameterNs)); } else { // case int[] parameter // case [XmlElement("parameter")] int[] parameter // case [XmlArray("parameter"), XmlArrayItem(ElementName = "item")] int[] parameter return(DeserializeArrayXmlSerializer(xmlReader, parameterType, parameterName, parameterNs, customAttributeProvider)); } case SoapSerializer.DataContractSerializer: return(DeserializeDataContract(xmlReader, parameterType, parameterName, parameterNs, knownTypes)); default: throw new NotImplementedException(); } } } if (parameterType.IsArray) { return(Array.CreateInstance(parameterType.GetElementType(), 0)); } return(null); }
public void test_serialization() { ActionCalendarEventRemove foo = new ActionCalendarEventRemove(Guid.NewGuid()), bar; DataContractSerializer fmt = new DataContractSerializer(typeof(ActionCalendarEventRemove)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (ActionCalendarEventRemove)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.guid, bar.guid); }
private object DeserializeDataContract(System.Xml.XmlDictionaryReader xmlReader, Type parameterType, string parameterName, string parameterNs) { var elementType = parameterType.GetElementType(); if (elementType == null || parameterType.IsArray) { elementType = parameterType; } var serializer = new DataContractSerializer(elementType, parameterName, parameterNs); return(serializer.ReadObject(xmlReader, verifyObjectName: true)); }
public void test_serialization() { CharNumProperty foo = new CharNumProperty(1.3m), bar; DataContractSerializer fmt = new DataContractSerializer(typeof(CharNumProperty)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (CharNumProperty)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.value, bar.value); }
public void test_serialization() { Topic foo = new Topic("Some topic", "A thing to know things about"), bar; DataContractSerializer fmt = new DataContractSerializer(typeof(Topic)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (Topic)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.name, bar.name); Assert.AreEqual(foo.description, bar.description); }
public override object ReadObject(System.Xml.XmlDictionaryReader reader, bool verifyObjectName) { if ((verifyObjectName == false)) { throw new System.NotSupportedException(); } if (this.info.IsWrapped) { // Some WSDLs incorrectly advertise their response message namespaces. // Attempt to interop with these by coercing our expected namespace to match. if ((this.serializer.CanDeserialize(reader) == false)) { this.createSerializer(new System.Xml.XmlQualifiedName(System.Xml.XmlConvert.DecodeName(reader.LocalName), reader.NamespaceURI)); } return(this.serializer.Deserialize(reader)); } else { System.IO.MemoryStream ms = new System.IO.MemoryStream(); System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings(); settings.OmitXmlDeclaration = true; System.Xml.XmlWriter innerWriter = System.Xml.XmlDictionaryWriter.Create(ms, settings); innerWriter.WriteStartElement(artificialWrapper.Name, artificialWrapper.Namespace); string[] commonPrefixes = new string[] { "xsi", "xsd" }; for (int i = 0; (i < commonPrefixes.Length); i = (i + 1)) { string ns = reader.LookupNamespace(commonPrefixes[i]); if ((ns != null)) { innerWriter.WriteAttributeString("xmlns", commonPrefixes[i], null, ns); } } for ( ; ((reader.NodeType == System.Xml.XmlNodeType.EndElement) == false); ) { innerWriter.WriteNode(reader, false); } innerWriter.WriteEndElement(); innerWriter.Close(); ms.Position = 0; System.Xml.XmlReader innerReader = System.Xml.XmlDictionaryReader.Create(ms); return(this.serializer.Deserialize(innerReader)); } }
public void test_serialization() { Task task = new Task(Guid.NewGuid(), "Some task"); ActionTaskCreate foo = new ActionTaskCreate(Guid.NewGuid(), task), bar; DataContractSerializer fmt = new DataContractSerializer(typeof(ActionTaskCreate)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (ActionTaskCreate)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.guid, bar.guid); Assert.AreEqual(foo.task.name, bar.task.name); }
public void test_serialization() { Note note = new Note("Some note", Guid.NewGuid()); ActionNoteCreate foo = new ActionNoteCreate(Guid.NewGuid(), note), bar; DataContractSerializer fmt = new DataContractSerializer(typeof(ActionNoteCreate)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (ActionNoteCreate)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.guid, bar.guid); Assert.AreEqual(foo.note.contents, bar.note.contents); }
private void processReply(System.ServiceModel.Channels.Message reply) { System.Diagnostics.Debug.Assert((reply != null)); if (reply.IsFault) { System.Xml.XmlDictionaryReader reader = reply.GetReaderAtBodyContents(); try { throw new CFFaultException(reader.ReadOuterXml()); } finally { reader.Close(); } } }
public object DeserializeInputParameter( System.Xml.XmlDictionaryReader xmlReader, Type parameterType, string parameterName, string parameterNs, MemberInfo memberInfo, IEnumerable <Type> knownTypes = null) { if (xmlReader.IsStartElement(parameterName, parameterNs)) { xmlReader.MoveToStartElement(parameterName, parameterNs); if (xmlReader.IsStartElement(parameterName, parameterNs)) { switch (_serializer) { case SoapSerializer.XmlSerializer: if (!parameterType.IsArray) { // case [XmlElement("parameter")] int parameter // case [XmlArray("parameter")] int[] parameter return(DeserializeObject(xmlReader, parameterType, parameterName, parameterNs)); } else { // case int[] parameter // case [XmlElement("parameter")] int[] parameter // case [XmlArray("parameter"), XmlArrayItem(ElementName = "item")] int[] parameter return(DeserializeArrayXmlSerializer(xmlReader, parameterType, parameterName, parameterNs, memberInfo)); } case SoapSerializer.DataContractSerializer: return(DeserializeDataContract(xmlReader, parameterType, parameterName, parameterNs, knownTypes)); default: throw new NotImplementedException(); } } } if (parameterType.IsArray) { return(Array.CreateInstance(parameterType.GetElementType(), 0)); } return(null); }
public void test_serialization() { CalendarEvent foo = new CalendarEvent(Guid.NewGuid(), 42, "Some event", "A thing that will happen every day", 86400), bar; DataContractSerializer fmt = new DataContractSerializer(typeof(CalendarEvent)); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { fmt.WriteObject(ms, foo); ms.Seek(0, System.IO.SeekOrigin.Begin); System.Xml.XmlDictionaryReader xr = System.Xml.XmlDictionaryReader.CreateTextReader(ms, new System.Xml.XmlDictionaryReaderQuotas()); bar = (CalendarEvent)(fmt.ReadObject(xr, true)); } Assert.AreEqual(foo.entry_guid, bar.entry_guid); Assert.AreEqual(foo.timestamp, bar.timestamp); Assert.AreEqual(foo.name, bar.name); Assert.AreEqual(foo.description, bar.description); Assert.AreEqual(foo.interval, bar.interval); }
private object DeserializeObject(System.Xml.XmlDictionaryReader xmlReader, Type parameterType, string parameterName, string parameterNs) { // see https://referencesource.microsoft.com/System.Xml/System/Xml/Serialization/XmlSerializer.cs.html#c97688a6c07294d5 var elementType = parameterType.GetElementType(); if (elementType == null || parameterType.IsArray) { elementType = parameterType; } var serializer = CachedXmlSerializer.GetXmlSerializer(elementType, parameterName, parameterNs); lock (serializer) { return(serializer.Deserialize(xmlReader)); } }
void Load() { using (System.Xml.XmlDictionaryReader jsonreader = System.Runtime.Serialization.Json.JsonReaderWriterFactory .CreateJsonReader(this.JSONByte, new System.Xml.XmlDictionaryReaderQuotas())) { try { if (jsonreader == null) { throw new Exception(string.Format("JsonUtil.Load(). {0}", "failed to load")); } ReadyRead(jsonreader); } finally { jsonreader.Close(); } } }