public XmlDocument RedeemCoupon(string requestXml) { const string methodName = "RedeemCoupon"; XmlWriter xmlWriter = null; StringWriter strWriter = null; var xmlResponse = new XmlDocument(); XmlDocument xmlInput = null; try { Startup(); m_connectorInc.Init_ResponseXML(ref strWriter, ref xmlWriter); if (IsValidXmlInput(xmlInput, xmlWriter, methodName, requestXml)) { var request = ConvertXmlToRedeemList(requestXml, "Coupon"); var response = m_trackableCoupon.RedeemCoupon(request); XmlSerializerCache.Create(response.Result.GetType(), new XmlRootAttribute(methodName)).Serialize(xmlWriter, response.Result); //m_connectorInc.Generate_Status_XML(ref xmlWriter, methodName, CMSException.StatusCodes.SUCCESS, m_phraseLib.Lookup("term.success"), true); } } catch (Exception ex) { ProcessException(ex, methodName, xmlWriter, strWriter); } CloseResponseXml(xmlWriter, strWriter, xmlResponse); Shutdown(); return(xmlResponse); }
public static T LoadFromXmlFile <T>(string filePath) { using (var ms = new MemoryStream(File.ReadAllBytes(filePath))) { return((T)XmlSerializerCache.GetXmlSerializer(typeof(T)).Deserialize(ms)); } }
public void BothCounters() { using (XmlSerializerCache cache = new XmlSerializerCache()) { string instanceName = PerfCounterManagerTests.GetCounterInstanceName(0); using (PerformanceCounter instanceCounter = new PerformanceCounter(PerfCounterManagerTests.CATEGORY , PerfCounterManagerTests.CACHED_INSTANCES_NAME , instanceName , true)) { Assert.AreEqual(0, instanceCounter.RawValue); using (PerformanceCounter hitCounter = new PerformanceCounter(PerfCounterManagerTests.CATEGORY , PerfCounterManagerTests.SERIALIZER_HITS_NAME , instanceName , true)) { Assert.AreEqual(0, hitCounter.RawValue); XmlRootAttribute root = new XmlRootAttribute("theRoot"); XmlSerializer ser = cache.GetSerializer(typeof(SerializeMe), root); Assert.AreEqual(1, instanceCounter.RawValue); Assert.AreEqual(0, hitCounter.RawValue); ser = cache.GetSerializer(typeof(SerializeMe), root); Assert.AreEqual(1, instanceCounter.RawValue); Assert.AreEqual(1, hitCounter.RawValue); } } } }
public void ReadXml(System.Xml.XmlReader reader) { reader.MoveToElement(); reader.ReadStartElement(); Type instanceType = base.GetType().BaseType; while (reader.IsStartElement()) { if (reader.HasAttributes) { XmlNodeType nodeType = reader.NodeType; Type t = typeof(FileProcessingJournalEntryData <>); t = t.MakeGenericType(Type.GetType(reader.GetAttribute("type"))); string name = reader.GetAttribute("name"); var ser = XmlSerializerCache.GetOrAdd(t, name); object obj = ser.Deserialize(reader.ReadSubtree()); reader.ReadEndElement(); this.EntryData.Add((FileProcessingJournalEntryDataBase)obj); } else { PropertyInfo Prop = instanceType.GetProperty(reader.Name); if (Prop != null) { var h = reader.ReadElementContentAsObject(Prop.Name, ""); Prop.SetValue(this, Convert.ChangeType(h, Prop.PropertyType), null); } } } }
public void WriteXml(System.Xml.XmlWriter writer) { Type instanceType = base.GetType().BaseType; foreach (PropertyInfo Prop in instanceType.GetProperties(BindingFlags.Public | BindingFlags.Instance)) { string value = null; object propertyValue = Prop.GetValue(this, null); if (propertyValue != null) { value = Prop.GetValue(this, null).ToString(); } writer.WriteElementString(Prop.Name, value); } foreach (IFileProcessingJournalEntryData entryData in this.EntryData) { var val = entryData.GetType().GetProperty("Value").GetValue(entryData, null); string name = (string)entryData.GetType().GetProperty("Name").GetValue(entryData, null); string type = (string)entryData.GetType().GetProperty("type").GetValue(entryData, null); var ser = XmlSerializerCache.GetOrAdd(entryData.GetType(), name); ser.Serialize(writer, entryData); } }
public virtual void ReadXml(System.Xml.XmlReader reader) { reader.MoveToContent(); if (reader.IsEmptyElement) { reader.Read(); ComputeVisibility(); return; } string localName = reader.LocalName; reader.Read(); while (true) { if (reader.LocalName == localName && reader.NodeType == System.Xml.XmlNodeType.EndElement) { break; } XmlSerializer serializer = null; switch (reader.LocalName) { case "LayoutAnchorablePaneGroup": serializer = XmlSerializerCache.Get <LayoutAnchorablePaneGroup>(); break; case "LayoutAnchorablePane": serializer = XmlSerializerCache.Get <LayoutAnchorablePane>(); break; case "LayoutAnchorable": serializer = XmlSerializerCache.Get <LayoutAnchorable>(); break; case "LayoutDocumentPaneGroup": serializer = XmlSerializerCache.Get <LayoutDocumentPaneGroup>(); break; case "LayoutDocumentPane": serializer = XmlSerializerCache.Get <LayoutDocumentPane>(); break; case "LayoutDocument": serializer = XmlSerializerCache.Get <LayoutDocument>(); break; case "LayoutAnchorGroup": serializer = XmlSerializerCache.Get <LayoutAnchorGroup>(); break; case "LayoutPanel": serializer = XmlSerializerCache.Get <LayoutPanel>(); break; } Children.Add((T)serializer.Deserialize(reader)); } reader.ReadEndElement(); }
/// <summary> /// Method to convert a custom Object to XML file /// </summary> /// <param name="obj">Object that is to be serialized to XML</param> /// <param name="fileName">Name of file to serialize in</param> /// <returns>XML string</returns> public void SerializeToFile <T>(T obj, string fileName) { var serializer = XmlSerializerCache.GetXmlSerializer(typeof(T)); using (Stream fs = new FileStream(fileName, FileMode.Create)) using (XmlWriter writer = new XmlTextWriter(fs, _encoding)) serializer.Serialize(writer, obj); }
public void WriteXml(XmlWriter writer) { writer.WriteAttributeString("type", type); writer.WriteAttributeString("name", Name); var ser = XmlSerializerCache.GetOrAdd(Type.GetType(this.type)); ser.Serialize(writer, this.Value); }
/// <summary> /// Method to reconstruct an Object from XML file /// </summary> /// <param name="fileName">File to read</param> /// <returns></returns> public T DeserializeFromFile <T>(string fileName) { var serializer = XmlSerializerCache.GetXmlSerializer(typeof(T)); using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) using (XmlReader reader = new XmlTextReader(fs)) return((T)serializer.Deserialize(reader)); }
public void InitType_ShouldNotInitializeXContainerTypes() { var cache = new XmlSerializerCache(); cache.InitType(typeof(XElement)); Assert.IsFalse(cache.typeMembers.ContainsKey(typeof(XElement))); }
public static void SaveToXmlFile(object data, string filePath) { var serializer = XmlSerializerCache.GetXmlSerializer(data.GetType()); using (var fs = new FileStream(filePath, FileMode.Create)) { serializer.Serialize(fs, data); fs.Flush(); } }
public void InitType_ShouldNotInfinitelyInitializeRecursiveTypes() { var cache = new XmlSerializerCache(); cache.InitType(typeof(RecursiveType)); var members = cache.typeMembers[typeof(RecursiveType)]; Assert.AreEqual(typeof(RecursiveType), members.Item1.Single().FieldType); Assert.AreEqual(typeof(RecursiveType), members.Item2.Single().PropertyType); }
/// <summary> /// Method to reconstruct an Object from XML byte array /// </summary> /// <param name="byteArray"></param> /// <returns></returns> public static T Deserialize <T>(byte[] byteArray) { if (byteArray == null || byteArray.Length <= 0) { return(default(T)); } var xs = XmlSerializerCache.GetXmlSerializer(typeof(T)); using (var memoryStream = new MemoryStream(byteArray)) return((T)xs.Deserialize(memoryStream)); }
/// <summary> /// Method to convert a custom Object to XML string /// </summary> /// <param name="obj">Object that is to be serialized to XML</param> /// <returns>XML string</returns> public byte[] SerializeToBytes <T>(T obj) { using (var memoryStream = new MemoryStream()) { var xs = XmlSerializerCache.GetXmlSerializer(typeof(T)); using (var xmlTextWriter = new XmlTextWriter(memoryStream, _encoding)) { xs.Serialize(xmlTextWriter, obj); return(memoryStream.ToArray()); } } }
public void InitType_ShouldHandleConcurrentInitializations() { var cache = new XmlSerializerCache(); Parallel.For(0, 10, _ => { cache.InitType(typeof(SimpleType)); var members = cache.typeMembers[typeof(SimpleType)]; Assert.NotNull(members); Assert.AreEqual(nameof(SimpleType.SimpleField), members.Item1.Single().Name); Assert.AreEqual(nameof(SimpleType.SimpleProperty), members.Item2.Single().Name); }); }
/// <summary> /// Load an object from an xml file /// </summary> /// <param name="FileName">Xml file name</param> /// <param name="o">the object to load to</param> /// <returns>The object created from the xml file</returns> public static SerializedNotification LoadFromFile(string FileName) { if (!File.Exists(FileName)) { return(null); } using ( var fileStream = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read, 16384, true)) { using (var streamReader = new StreamReader(fileStream, Encoding.UTF8)) { return(XmlSerializerCache.Deserialize <SerializedNotification>(streamReader)); } } }
public static T LoadFromXmlString <T>(string value) { var serializer = XmlSerializerCache.GetXmlSerializer(typeof(T)); using (var ms = new MemoryStream()) { using (var sw = new StreamWriter(ms)) { sw.WriteLine(value); sw.Flush(); ms.Position = 0; return((T)serializer.Deserialize(ms)); } } }
private static Type DetermineMessageType(IEnumerable <Type> possibleTypes, string messageBody) { foreach (var type in possibleTypes) { var xmlSerializer = XmlSerializerCache.GetSerializer(type); using (var tmpStringReader = new StringReader(messageBody)) { if (xmlSerializer.CanDeserialize(XmlReader.Create(tmpStringReader))) { return(type); } } } // If we got here, we didn't find a matching message type. return(null); }
public void ReadXml(XmlReader reader) { Type t = Type.GetType(reader.GetAttribute("type")); this.type = t.AssemblyQualifiedName; this.Name = reader.GetAttribute("name"); var ser = XmlSerializerCache.GetOrAdd(t); reader.ReadStartElement(); object obj = ser.Deserialize(reader.ReadSubtree()); PropertyInfo prop = this.GetType().GetProperty("Value"); prop.SetValue(this, Convert.ChangeType(obj, t), null); if (!reader.IsEmptyElement) { reader.ReadEndElement(); } else { reader.Read(); } }
public MazeTaskReaderTests() { _serializerCache = new XmlSerializerCache(); }
public void SetUp() { cache = new XmlSerializerCache(); ClearFlags(); ConnectListeners(); }
public void TearDown() { DisonnectListeners(); cache.Dispose(); cache = null; }