/// <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();
}
}
}
