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