protected virtual void doWriteXml(XmlWriter writer)
{
writer.WriteAttributeString("assembly", CurrentAssemblyName);
writer.WriteAttributeString("Orientation", this.Orientation.ToString());
writer.WriteAttributeString("Position", this.Position.ToString());
writer.WriteAttributeString("MaxPosition", this.MaxPosition.ToString());
writer.WriteAttributeString("MinPosition", this.MinPosition.ToString());
writer.WriteAttributeString("Expand", this.Expand.ToString());
writer.WriteStartElement("item");
IXmlSerializable xmlitm = Widget1 as IXmlSerializable;
if (xmlitm != null)
{
xmlitm.WriteXml(writer);
}
writer.WriteEndElement();
writer.WriteStartElement("childbox");
if (container2 != null)
{
container2.WriteXml(writer);
}
writer.WriteEndElement();
}
public static string Serialize(object obj)
{
TextWriter tw = new StringWriter();
try
{
Type objType = obj.GetType();
IXmlSerializable serializableObj = obj as IXmlSerializable;
if (serializableObj != null)
{
using (XmlWriter writer = XmlWriter.Create(tw))
{
writer.WriteStartDocument();
writer.WriteStartElement(objType.Name);
serializableObj.WriteXml(writer);
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
else
{
XmlSerializer serializer = new XmlSerializer(objType);
serializer.Serialize(tw, obj);
}
}
catch (Exception e)
{
MobileDebug.Service.WriteEvent("XmlSerializeFail", e);
}
return(tw.ToString());
}
public static void ReadElement(XmlReader reader, string localName, IXmlSerializable instance)
{
if (reader.IsStartElement(localName))
{
instance.ReadXml(reader);
}
}
public override void SetXmlInstance(object inst, XamlMember property, XData xData)
{
IXmlSerializable serializable = this.GetValue(inst, property, true) as IXmlSerializable;
if (serializable == null)
{
throw this.CreateException(System.Xaml.SR.Get("XmlDataNull", new object[] { property.Name }));
}
XmlReader xmlReader = xData.XmlReader as XmlReader;
if (xmlReader == null)
{
throw new XamlInternalException(System.Xaml.SR.Get("XmlValueNotReader", new object[] { property.Name }));
}
try
{
serializable.ReadXml(xmlReader);
}
catch (Exception exception)
{
if (CriticalExceptions.IsCriticalException(exception))
{
throw;
}
throw this.CreateException(System.Xaml.SR.Get("SetXmlInstance", new object[] { property }), exception);
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.MoveToAttribute("Disabled"))
{
Disabled = reader.Value == "1";
}
reader.ReadStartElement("RuleList");
while (reader.IsStartElement())
{
IXmlSerializable r = null;
switch (reader.Name)
{
case "RegExpRule":
r = new RegExpRule();
break;
case "HostRule":
r = new HostRule();
break;
case "PathRule":
r = new PathRule();
break;
}
if (r != null)
{
r.ReadXml(reader.ReadSubtree());
this.Add((IRule)r);
}
reader.ReadEndElement();
}
}
private void DisplayXmlIfSelected(IXmlSerializable exception)
{
if (tabsView.SelectedIndex != 2 || _xmlWritten)
{
return;
}
if (exception == null)
{
rtfXml.Text = string.Empty;
}
else
{
using (var stringWriter = new StringWriter())
{
XmlTextWriter writer = new XmlRichTextWriter(stringWriter)
{
Formatting = Formatting.Indented,
Indentation = 2
};
exception.WriteOuterXml(writer);
writer.Close();
rtfXml.Rtf = stringWriter.ToString();
}
}
_xmlWritten = true;
}
public override void WriteXml(XmlWriter writer)
{
base.WriteXml(writer);
writer.WriteStartElement("Villages");
writer.WriteAttributeString <int>("Count", this.villages.Count);
for (int i = 0; i < this.villages.Count; i++)
{
if (this.villages[i].HasBeenConverted)
{
Diagnostics.Assert(this.villages[i].HasBeenConvertedBy != null);
Diagnostics.Assert(this.villages[i].HasBeenConvertedByIndex != -1);
Diagnostics.Assert(this.villages[i].HasBeenConvertedByIndex == this.villages[i].HasBeenConvertedBy.Index);
IXmlSerializable xmlSerializable = null;
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable);
}
else if (this.villages[i].IsInfectionComplete)
{
IXmlSerializable xmlSerializable = null;
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable);
}
else
{
IXmlSerializable xmlSerializable = this.villages[i];
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable);
}
}
writer.WriteEndElement();
}
public virtual void WriteXml(XmlWriter writer)
{
int num = writer.WriteVersionAttribute(3);
writer.WriteElementString <int>("OwnerEmpireIndex", this.OwnerEmpireIndex);
writer.WriteElementString <int>("OtherEmpireIndex", this.OtherEmpireIndex);
string value = string.Empty;
if (this.State != null)
{
value = this.State.Name;
}
writer.WriteElementString <string>("State", value);
writer.WriteElementString <int>("TurnAtTheBeginningOfTheState", this.TurnAtTheBeginningOfTheState);
writer.WriteStartElement("DiplomaticAbilities");
Diagnostics.Assert(this.diplomaticAbilities != null);
writer.WriteAttributeString <int>("Count", this.diplomaticAbilities.Count);
for (int i = 0; i < this.diplomaticAbilities.Count; i++)
{
Diagnostics.Assert(this.diplomaticAbilities[i] != null);
IXmlSerializable xmlSerializable = this.diplomaticAbilities[i];
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable);
}
writer.WriteEndElement();
if (num >= 2)
{
IXmlSerializable xmlSerializable2 = this.score;
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable2);
}
}
private static void WriteIXmlSerializable(XmlWriterDelegator xmlWriter, object obj, XmlSerializableWriter xmlSerializableWriter)
{
xmlSerializableWriter.BeginWrite(xmlWriter.Writer, obj);
IXmlSerializable serializable = obj as IXmlSerializable;
if (serializable != null)
{
serializable.WriteXml(xmlSerializableWriter);
}
else
{
XmlElement element = obj as XmlElement;
if (element != null)
{
element.WriteTo(xmlSerializableWriter);
}
else
{
System.Xml.XmlNode[] nodeArray = obj as System.Xml.XmlNode[];
if (nodeArray == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("UnknownXmlType", new object[] { DataContract.GetClrTypeFullName(obj.GetType()) })));
}
foreach (System.Xml.XmlNode node in nodeArray)
{
node.WriteTo(xmlSerializableWriter);
}
}
}
xmlSerializableWriter.EndWrite();
}
/// <summary>Transforms the specified type into a string that is fit to be traced.</summary>
/// <param name="xml">The type to transform.</param>
/// <returns>The string.</returns>
internal protected static string ToTraceString(IXmlSerializable xml)
{
var sb=new StringBuilder();
using (var xw=XmlWriter.Create(sb))
xml.WriteXml(xw);
return sb.ToString();
}
/// <summary>
/// Deserialize xml file to object.
/// </summary>
/// <param name="obj">The object implements IXmlSerializable.</param>
/// <param name="fileName">The name of file used to stored object.</param>
public static void Deserialize(IXmlSerializable obj, string fileName)
{
if (!File.Exists(fileName))
{
return;
}
FileStream fs = null;
XmlReader reader = null;
try {
fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
reader = new XmlTextReader(fs);
obj.ReadXml(reader);
}
catch {
}
finally {
//Throw
if (fs != null)
{
fs.Close();
}
}
}
/// <summary>
/// Serialize object to file.
/// </summary>
/// <param name="obj">The object implements IXmlSerializable.</param>
/// <param name="fileName">The name of file used to stored object.</param>
public static void Serialize(IXmlSerializable obj, string fileName)
{
FileStream fs = null;
XmlWriter write = null;
try {
fs = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
write = new XmlTextWriter(fs, Encoding.Default);
obj.WriteXml(write);
}
catch {
throw;
}
finally {
if (fs != null)
{
fs.Close();
}
}
}
private string ToSerializable(IXmlSerializable serializable)
{
if (serializable == null)
{
return(null);
}
try
{
using (var memory = new MemoryStream())
using (var writer = XmlWriter.Create(memory))
{
writer.WriteStartDocument();
serializable.WriteXml(writer);
writer.WriteEndDocument();
writer.Flush();
memory.Seek(0L, SeekOrigin.Begin);
return(Encoding.UTF8.GetString(memory.GetBuffer(), 0, (int)memory.Length));
}
}
catch (Exception e)
{
Log.ErrorException(e, "Error serializing object of type {0}", serializable.GetType().FullName);
return(null);
}
}
/// <summary>
/// Deserialize xml string to object.
/// </summary>
/// <param name="data">Deserialized string</param>
/// <param name="obj">The object implements IXmlSerializable.</param>
public static void Deserialize(string data, IXmlSerializable obj)
{
if (data.Equals(string.Empty))
{
return;
}
XmlReader reader = null;
StringReader sr = null;
try {
sr = new StringReader(data);
reader = new XmlTextReader(sr);
obj.ReadXml(reader);
}
catch {
}
finally {
if (sr != null)
{
sr.Close();
}
}
}
public static void Serialize(string filePath, IXmlSerializable obj)
{
XmlSerializer serializer = new XmlSerializer(obj.GetType());
using (StreamWriter writer = new StreamWriter(filePath))
serializer.Serialize(writer, obj);
}
public override void WriteXml(XmlWriter writer)
{
int num = writer.WriteVersionAttribute(5);
writer.WriteAttributeString <int>("EmpireTarget", this.EmpireTarget);
writer.WriteAttributeString <float>("MilitaryStress", this.Priority);
writer.WriteAttributeString <int>("ExecutionState", (int)this.ExecutionState);
if (num >= 2)
{
writer.WriteAttributeString <int>("ForceSourceRegion", this.ForceSourceRegion);
writer.WriteAttributeString <float>("MinimumNeededArmyFulfillement", this.MinimumNeededArmyFulfillement);
writer.WriteAttributeString <float>("CurrentFulfillement", this.CurrentFulfillement);
writer.WriteAttributeString <float>("MissingMilitaryPower", this.MissingMilitaryPower);
writer.WriteAttributeString <bool>("OnlyMercenaries", this.OnlyMercenaries);
if (num >= 5)
{
writer.WriteAttributeString <AICommanderMissionDefinition.AICommanderCategory>("CommanderCategoryEnum", this.CommanderCategory);
}
}
base.WriteXml(writer);
if (this.ArmyPattern != null)
{
IXmlSerializable armyPattern = this.ArmyPattern;
writer.WriteElementSerializable <IXmlSerializable>(ref armyPattern);
}
IXmlSerializable xmlSerializable = this.FinalPosition;
writer.WriteElementSerializable <IXmlSerializable>("FinalPosition", ref xmlSerializable);
}
// SetXmlInstance: receives the value as "object" so the calling code doesn't
// need to load System.Xml.dll types to make the call.
public override void SetXmlInstance(object inst, XamlMember property, XAML3.XData xData)
{
object propInstance = GetValue(inst, property, true);
IXmlSerializable iXmlSerial = propInstance as IXmlSerializable;
if (iXmlSerial == null)
{
throw CreateException((SR.Get(SRID.XmlDataNull, property.Name)));
}
XmlReader reader = xData.XmlReader as XmlReader;
if (reader == null)
{
throw new XamlInternalException(SR.Get(SRID.XmlValueNotReader, property.Name));
}
try
{
iXmlSerial.ReadXml(reader);
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e))
{
throw;
}
throw CreateException(SR.Get(SRID.SetXmlInstance, property), e);
}
}
internal static object ReadIXmlSerializable(XmlSerializableReader xmlSerializableReader, XmlReaderDelegator xmlReader, XmlDataContract xmlDataContract, bool isMemberType)
{
object obj = null;
xmlSerializableReader.BeginRead(xmlReader);
if (isMemberType && !xmlDataContract.HasRoot)
{
xmlReader.Read();
xmlReader.MoveToContent();
}
if (xmlDataContract.UnderlyingType == Globals.TypeOfXmlElement)
{
if (!xmlReader.IsStartElement())
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader));
}
XmlDocument xmlDoc = new XmlDocument();
obj = (XmlElement)xmlDoc.ReadNode(xmlSerializableReader);
}
else if (xmlDataContract.UnderlyingType == Globals.TypeOfXmlNodeArray)
{
obj = XmlSerializableServices.ReadNodes(xmlSerializableReader);
}
else
{
IXmlSerializable xmlSerializable = xmlDataContract.CreateXmlSerializableDelegate();
xmlSerializable.ReadXml(xmlSerializableReader);
obj = xmlSerializable;
}
xmlSerializableReader.EndRead();
return(obj);
}
public void ReadXml(XmlReader reader)
{
_dialect = reader.GetAttribute(DialectAttribute);
Type type = FilterMapExtension.GetDialectType(_dialect);
if (type == null)
{
throw CreateNotSupportedDialectException();
}
if (type == typeof(void))
{
return;
}
if (typeof(IXmlSerializable).IsAssignableFrom(type))
{
IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(type);
serializable.ReadXml(reader);
return;
}
XmlSerializer serializer = new XmlSerializer(type);
if (!reader.IsEmptyElement)
{
reader.ReadStartElement("Filter", reader.NamespaceURI);
_value = serializer.Deserialize(reader);
reader.ReadEndElement();
}
}
public static bool GetCollectionValue <T>(XmlNode xml, string xpath, IXmlSerializable obj, out IList <T> objList)
{
XmlNodeList nodes = GetNodes(xml, xpath);
if (nodes != null)
{
objList = new List <T>();
foreach (XmlNode node in nodes)
{
try
{
object obj2;
if (GetSerializedObject(node, obj, out obj2))
{
objList.Add((T)obj2);
}
continue;
}
catch (Exception)
{
continue;
}
}
return(objList.Count > 0);
}
objList = null;
return(false);
}
public virtual void WriteXml(XmlWriter writer)
{
writer.WriteStartElement("Helpers");
writer.WriteAttributeString <int>("Count", this.aiHelpers.Count);
foreach (KeyValuePair <Type, AIHelper> keyValuePair in this.aiHelpers)
{
IXmlSerializable value = keyValuePair.Value;
writer.WriteElementSerializable <IXmlSerializable>(ref value);
}
writer.WriteEndElement();
writer.WriteStartElement("AIPlayer_MajorEmpires");
writer.WriteAttributeString <int>("Count", this.aiPlayerMajorEmpires.Count);
for (int i = 0; i < this.aiPlayerMajorEmpires.Count; i++)
{
IXmlSerializable xmlSerializable = this.aiPlayerMajorEmpires[i];
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable);
}
writer.WriteEndElement();
IXmlSerializable xmlSerializable2 = this.aiPlayerMinorEmpire;
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable2);
IXmlSerializable xmlSerializable3 = this.aiPlayerLesserEmpire;
writer.WriteElementSerializable <IXmlSerializable>(ref xmlSerializable3);
IXmlSerializable xmlSerializable4 = this.aiPlayerNavalEmpire;
writer.WriteElementSerializable <IXmlSerializable>("AIPlayer_NavalEmpire", ref xmlSerializable4);
}
public static bool SetInnerXml(ref XmlNode xml, string localElementName, IXmlSerializable obj)
{
if ((xml == null) || (obj == null))
{
return(false);
}
StringBuilder output = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Fragment;
XmlWriter writer = XmlWriter.Create(output, settings);
if (!TypeHelper.IsNullOrEmpty(localElementName))
{
writer.WriteStartElement(localElementName);
}
obj.WriteXml(writer);
if (!TypeHelper.IsNullOrEmpty(localElementName))
{
writer.WriteEndElement();
}
writer.Close();
xml.InnerXml = output.ToString();
return(true);
}
private static void WriteIXmlSerializable(XmlWriterDelegator xmlWriter, object obj, XmlSerializableWriter xmlSerializableWriter)
{
xmlSerializableWriter.BeginWrite(xmlWriter.Writer, obj);
IXmlSerializable xmlSerializable = obj as IXmlSerializable;
if (xmlSerializable != null)
{
xmlSerializable.WriteXml(xmlSerializableWriter);
}
else
{
XmlElement xmlElement = obj as XmlElement;
if (xmlElement != null)
{
xmlElement.WriteTo(xmlSerializableWriter);
}
else
{
XmlNode[] xmlNodes = obj as XmlNode[];
if (xmlNodes != null)
{
foreach (XmlNode xmlNode in xmlNodes)
{
xmlNode.WriteTo(xmlSerializableWriter);
}
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.UnknownXmlType, DataContract.GetClrTypeFullName(obj.GetType()))));
}
}
}
xmlSerializableWriter.EndWrite();
}
public static bool GetSerializedObject(string xml, IXmlSerializable obj, out object result)
{
if ((xml != null) && (xml != string.Empty))
{
bool flag;
try
{
if (!xml.TrimStart().StartsWith("<?xml"))
{
xml = "<?xml version=\"1.0\" encoding=\"utf-16\" ?>" + xml;
}
result = Serializer.ConvertToObject(xml, obj.GetType());
if (result == null)
{
return(false);
}
flag = true;
}
catch
{
result = null;
flag = false;
}
return(flag);
}
else
{
result = null;
return(false);
}
}
public void WriteXmlTest()
{
var recentFileList = new RecentFileList();
IXmlSerializable serializable = recentFileList;
serializable.WriteXml(null);
}
protected void Page_Load(object sender, EventArgs e)
{
var parameters = new NameValueCollection();
parameters["service"] = "CSW";
parameters["version"] = "2.0.2";
parameters["request"] = "GetCapabilities";
try
{
var sb = new StringBuilder();
using (var xw = XmlWriter.Create(sb))
{
IXmlSerializable response = Services.Ows.ServiceLocatorInstance.InvokeServiceAsync(parameters, CancellationToken.None).Result;
response.WriteXml(xw);
}
_Label1.Text = HttpUtility.HtmlEncode(sb.ToString());
} catch (Exception ex)
{
_Label1.Text =
ex.Message +
"<br />" +
ex.StackTrace
;
if (ex.InnerException != null)
{
_Label1.Text +=
"<br />" +
ex.InnerException.Message +
"<br />" +
ex.InnerException.StackTrace
;
}
}
}
/// <summary>写入实现了可序列化接口的对象</summary>
/// <param name="value">要写入的对象</param>
/// <param name="type">要写入的对象类型，如果type等于DataTable，需设置DataTable的名称</param>
/// <param name="callback">处理成员的方法</param>
/// <returns>是否写入成功</returns>
public override bool WriteSerializable(object value, Type type, WriteObjectCallback callback)
{
if (!typeof(IXmlSerializable).IsAssignableFrom(type))
{
return(base.WriteSerializable(value, type, callback));
}
try
{
IXmlSerializable xml = value as IXmlSerializable;
// 这里必须额外写一对标记，否则读取的时候只能读取得到模式而得不到数据
Boolean b = xml.GetSchema() != null;
if (b)
{
Writer.WriteStartElement("Data");
}
xml.WriteXml(Writer);
if (b)
{
Writer.WriteEndElement();
}
return(true);
}
catch
{
return(base.WriteSerializable(value, type, callback));
}
}
public void ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
return;
}
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
string key = reader.LocalName;
string type = reader.GetAttribute("type");
SaveValue saveValue = SaveValue.Instantiate(type);
IXmlSerializable xmlSerializable = saveValue as IXmlSerializable;
if (xmlSerializable != null)
{
xmlSerializable.ReadXml(reader);
_items[key] = saveValue;
}
if (reader.EOF)
{
throw new IOException("Malformed XML file");
}
}
reader.ReadEndElement();
}
public static IXmlSerializable CreateByTypeAttribute(XmlReader reader)
{
reader.ReadStartElement();
if (!reader.IsStartElement())
{
return(null);
}
//reader.ReadStartElement();
// reader.MoveToAttribute("type");
// if (!reader.ReadAttributeValue()) { }
string typeString = reader.GetAttribute("type");
if (typeString == null)
{
throw new NullReferenceException();
}
else
{
Type type = Type.GetType(typeString);
IXmlSerializable obj = (IXmlSerializable)type.GetConstructor(new Type[0]).Invoke(new object[0]);
obj.ReadXml(reader);
if (!reader.IsEmptyElement)
{
reader.ReadEndElement();
}
//reader.Skip();
return(obj);
}
}
public void ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
reader.Read();
return;
}
reader.ReadStartElement();
while (reader.NodeType != XmlNodeType.EndElement)
{
string type = reader.GetAttribute("type");
SaveValue saveValue = SaveValue.Instantiate(type);
IXmlSerializable xmlSerializable = saveValue as IXmlSerializable;
if (xmlSerializable != null)
{
xmlSerializable.ReadXml(reader);
_items.Add(saveValue);
}
}
reader.ReadEndElement();
}
public override void WriteXml(XmlWriter writer)
{
base.WriteXml(writer);
IXmlSerializable armyMission = this.ArmyMission;
writer.WriteElementSerializable <IXmlSerializable>(ref armyMission);
}
private static Message CreateMessage(IXmlSerializable response, MessageVersion version)
{
StringBuilder serialized=new StringBuilder();
using (var xw=XmlWriter.Create(serialized))
response.WriteXml(xw);
var xr=XmlReader.Create(new StringReader(serialized.ToString()));
return Message.CreateMessage(version, "ExecuteResponse", xr);
}
/// <summary>Creates a new instance of the <see cref="XmlSerializableResult" /> class.</summary>
/// <param name="result">The result to serialize to the response stream output.</param>
public XmlSerializableResult(IXmlSerializable result)
{
Debug.Assert(result!=null);
if (result==null)
throw new ArgumentNullException("result");
_Result=result;
}
public SurrogateForIXmlSerializable(IXmlSerializable serializable)
{
assemblyQualifiedName = serializable.GetType().AssemblyQualifiedName;
using(var stream = new MemoryStream())
{
var xmlSerializer = new XmlSerializer(serializable.GetType());
xmlSerializer.Serialize(stream, serializable);
bytes = stream.ToArray();
}
}
public void Wrap(object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (!(obj is IXmlSerializable))
{
throw new ArgumentException("obj not an IXmlSerializable interface");
}
this._content = obj as IXmlSerializable;
}
public static string WriteXml(IXmlSerializable target)
{
StringBuilder sb = new StringBuilder();
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.ConformanceLevel = ConformanceLevel.Fragment;
using (XmlWriter writer = XmlTextWriter.Create(sb, xmlWriterSettings))
{
XmlRootAttribute[] xmlRootAttribute = target.GetType().GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[];
writer.WriteStartElement(xmlRootAttribute[0].ElementName);
target.WriteXml(writer);
writer.WriteEndElement();
}
return sb.ToString();
}
public ContestResults(string contestGuid, string techniqueName, string techniqueDescription, List<DatasetResultsDTO> results, double score, IXmlSerializable baseData)
{
ContestGUID = contestGuid;
TechniqueName = techniqueName;
TechniqueDescription = techniqueDescription;
Results = results;
Score = score;
//
var serializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(baseData.GetType(), null);
using (MemoryStream memorystream = new MemoryStream())
{
serializer.Serialize(memorystream, baseData);
string xmlObject = Encoding.Default.GetString(memorystream.ToArray());
BaseData = xmlObject;
}
}
private bool CheckExceptions(IXmlSerializable instance)
{
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.GetSchema();
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_GetSchema, Type.Name));
}
catch (NotSupportedException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.ReadXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_ReadXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
try
{
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
instance.WriteXml(null);
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
throw new UnitTestException(string.Format(CultureInfo.InvariantCulture, Resources.XmlSerialization_WriteXmlNull, Type.Name));
}
catch (ArgumentNullException)
{
}
return true;
}
/// <include file='doc\XmlSerializationReader.uex' path='docs/doc[@for="XmlSerializationReader.ReadSerializable"]/*' />
protected IXmlSerializable ReadSerializable(IXmlSerializable serializable) {
return ReadSerializable(serializable, false);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="ItemSchemeMapCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="id">
/// The id.
/// </param>
/// <param name="uri">
/// The uri.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <param name="annotationsType">
/// The annotations type.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected ItemSchemeMapCore(
IXmlSerializable createdFrom,
SdmxStructureType structureType,
string id,
Uri uri,
IList<TextType> name,
IList<TextType> description,
AnnotationsType annotationsType,
IIdentifiableObject parent)
: base(createdFrom, structureType, id, uri, name, description, annotationsType, parent)
{
this._items = new List<IItemMap>();
}
public static Xlob Create(IXmlSerializable obj)
{
return new XmlSerializableObjectXlob(obj);
}
void WriteSerializable (IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped)
{
if (serializable == null)
{
if (isNullable && wrapped) WriteNullTagLiteral (name, ns);
return;
}
else
{
if (wrapped)
Writer.WriteStartElement (name, ns);
serializable.WriteXml (Writer);
if (wrapped)
Writer.WriteEndElement ();
}
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
public void ReadXml(System.Xml.XmlReader reader)
{
XPathDocument doc = new XPathDocument(reader);
XPathNavigator nav = doc.CreateNavigator();
XPathNavigator iter = nav.SelectSingleNode("TLExperimentResults/TechniqueName");
if (iter != null)
TechniqueName = iter.Value;
iter = nav.SelectSingleNode("TLExperimentResults/Score");
if (iter != null)
{
Score = iter.ValueAsDouble;
}
iter = nav.SelectSingleNode("TLExperimentResults/BaseData");
if (iter != null)
{
string qualifiedTypeName = iter.GetAttribute("type", String.Empty);
Type baseDataType = Type.GetType(qualifiedTypeName);
if (baseDataType != null)
{
var serializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(baseDataType, null);
iter.MoveToChild(XPathNodeType.Element); //move to nodes value
BaseData = (IXmlSerializable)serializer.Deserialize(iter.ReadSubtree());
}
}
var datasetsResultSerializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(DatasetResults), null);
iter = nav.SelectSingleNode("TLExperimentResults/DatasetsResults");
if (iter != null)
{
m_datasetsResults = new List<DatasetResults>();
XPathNodeIterator resultsNodes = iter.Select("DatasetResults");
while (resultsNodes.MoveNext())
{
var result = (DatasetResults)datasetsResultSerializer.Deserialize(resultsNodes.Current.ReadSubtree());
m_datasetsResults.Add(result);
}
}
iter = nav.SelectSingleNode("TLExperimentResults/AcrossAllDatasetsResults");
if (iter != null)
{
iter.MoveToChild(XPathNodeType.Element); //move to nodes value
AcrossAllDatasetsResults = (DatasetResults)datasetsResultSerializer.Deserialize(iter.ReadSubtree());
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="NameableCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="id">
/// The id.
/// </param>
/// <param name="uri">
/// The uri.
/// </param>
/// <param name="name0">
/// The name 0.
/// </param>
/// <param name="description1">
/// The description 1.
/// </param>
/// <param name="annotationsType">
/// The annotations type.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected NameableCore(
IXmlSerializable createdFrom,
SdmxStructureType structureType,
string id,
Uri uri,
IList<Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.TextType> name0,
IList<Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.TextType> description1,
Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.AnnotationsType annotationsType,
IIdentifiableObject parent)
: base(createdFrom, structureType, id, uri, annotationsType, parent)
{
this.name = new List<ITextTypeWrapper>();
this.description = new List<ITextTypeWrapper>();
this.name = TextTypeUtil.WrapTextTypeV1(name0, this);
this.description = TextTypeUtil.WrapTextTypeV1(description1, this);
this.ValidateNameableAttributes();
}
/// <summary>
/// Reads the data. (allows faster custom serialization for better performance in TraceLab)
/// </summary>
/// <param name="reader">The reader.</param>
public void ReadData(System.IO.BinaryReader reader)
{
int dataversion = reader.ReadInt32();
if (dataversion != TLExperimentResults.version)
{
throw new InvalidOperationException("Binary reader did not read correct data version. Data corrupted. Potentially IRawSerializable not implemented correctly");
}
else
{
this.m_techniqueName = reader.ReadString();
int resultsCount = reader.ReadInt32();
this.m_datasetsResults = new List<DatasetResults>(resultsCount);
for (int i = 0; i < resultsCount; i++)
{
DatasetResults result = (DatasetResults)Activator.CreateInstance(typeof(DatasetResults), true);
result.ReadData(reader);
this.m_datasetsResults.Add(result);
}
this.m_score = reader.ReadDouble();
bool isMemberPresent = reader.ReadBoolean();
if (isMemberPresent)
{
DatasetResults result = (DatasetResults)Activator.CreateInstance(typeof(DatasetResults), true);
result.ReadData(reader);
this.m_acrossAllDatasetsResults = result;
}
this.m_baseData = null;
}
}
/// <include file='doc\XmlSerializationWriter.uex' path='docs/doc[@for="XmlSerializationWriter.WriteSerializable"]/*' />
protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable) {
WriteSerializable(serializable, name, ns, isNullable, true);
}
protected IXmlSerializable ReadSerializable (IXmlSerializable serializable)
{
if (ReadNull ()) return null;
int depth = reader.Depth;
readCount++;
serializable.ReadXml (reader);
Reader.MoveToContent ();
while (reader.Depth > depth)
reader.Skip ();
if (reader.Depth == depth && reader.NodeType == XmlNodeType.EndElement)
reader.ReadEndElement ();
return serializable;
}
public XmlSerializableObjectXlob(IXmlSerializable obj)
{
if (obj == null) throw new ArgumentNullException("obj");
_obj = obj;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="SchemeMapCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="id">
/// The id.
/// </param>
/// <param name="uri">
/// The uri.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <param name="annotationsType">
/// The annotations type.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
internal SchemeMapCore(
IXmlSerializable createdFrom,
SdmxStructureType structureType,
string id,
Uri uri,
IList<TextType> name,
IList<TextType> description,
AnnotationsType annotationsType,
IIdentifiableObject parent)
: base(createdFrom, structureType, id, uri, name, description, annotationsType, parent)
{
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="IdentifiableCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="id0">
/// The id 0.
/// </param>
/// <param name="uri1">
/// The uri 1.
/// </param>
/// <param name="annotationsType">
/// The annotations type.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected IdentifiableCore(IXmlSerializable createdFrom, SdmxStructureType structureType, string id0, Uri uri1, AnnotationsType annotationsType, ISdmxStructure parent)
: base(createdFrom, annotationsType, structureType, parent)
{
this._id = id0;
this.Uri = uri1;
this.ValidateIdentifiableAttributes();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="IdentifiableCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="id0">
/// The id 0.
/// </param>
/// <param name="uri1">
/// The uri 1.
/// </param>
/// <param name="annotationsType">
/// The annotations type.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected IdentifiableCore(
IXmlSerializable createdFrom, SdmxStructureType structureType, string id0, Uri uri1, Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.AnnotationsType annotationsType, ISdmxStructure parent)
: base(createdFrom, annotationsType, structureType, parent)
{
this._id = id0;
this.Uri = uri1;
this.ValidateIdentifiableAttributes();
}
private static void SerializeCustom(XmlWriter writer, XPathResult result, XPathNavigator node, IXmlSerializable value)
{
if (string.IsNullOrEmpty(node.NamespaceURI))
{
writer.WriteStartElement(node.LocalName);
}
else
{
var prefix = result.Context.AddNamespace(node.NamespaceURI);
writer.WriteStartElement(prefix, node.LocalName, node.NamespaceURI);
}
value.WriteXml(writer);
writer.WriteEndElement();
}
/// <include file='doc\XmlSerializationReader.uex' path='docs/doc[@for="XmlSerializationReader.ReadSerializable"]/*' />
protected IXmlSerializable ReadSerializable(IXmlSerializable serializable, bool wrappedAny)
{
string name = null;
string ns = null;
if (wrappedAny) {
name = r.LocalName;
ns = r.NamespaceURI;
r.Read();
r.MoveToContent();
}
serializable.ReadXml(r);
if (wrappedAny) {
while (r.NodeType == XmlNodeType.Whitespace) r.Skip();
if (r.NodeType == XmlNodeType.None) r.Skip();
if (r.NodeType == XmlNodeType.EndElement && r.LocalName == name && r.NamespaceURI == ns) {
Reader.Read();
}
}
return serializable;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="ComponentCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="annotationType">
/// The annotation type.
/// </param>
/// <param name="codelistId">
/// The codelist id.
/// </param>
/// <param name="conceptId">
/// The concept id.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected internal ComponentCore(
IXmlSerializable createdFrom,
SdmxStructureType structureType,
Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.AnnotationsType annotationType,
string codelistId,
string conceptId,
ISdmxStructure parent)
: base(createdFrom, structureType, conceptId, null, annotationType, parent)
{
if (!string.IsNullOrWhiteSpace(codelistId))
{
this.LocalRepresentation = new RepresentationCore(codelistId, this);
}
this._conceptRef = new CrossReferenceImpl(
this,
this.MaintainableParent.AgencyId,
ConceptSchemeObject.DefaultSchemeVersion,
ConceptSchemeObject.DefaultSchemeVersion,
SdmxStructureEnumType.Concept,
conceptId);
this.ValidateComponentAttributes();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="AnnotableCore" /> class.
/// </summary>
/// <param name="createdFrom"> The created from. </param>
/// <param name="annotationType"> The annotation type. </param>
/// <param name="structureType"> The structure type. </param>
/// <param name="parent"> The parent. </param>
protected internal AnnotableCore(
IXmlSerializable createdFrom,
Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.AnnotationsType annotationType,
SdmxStructureType structureType,
ISdmxStructure parent)
: base(structureType, parent)
{
this.annotations = new List<IAnnotation>();
if (annotationType != null && annotationType.Annotation != null)
{
foreach (Org.Sdmx.Resources.SdmxMl.Schemas.V10.common.AnnotationType currentAnnotation in
annotationType.Annotation)
{
this.annotations.Add(new AnnotationObjectCore(currentAnnotation, this));
}
}
}
/// <include file='doc\XmlSerializationReader.uex' path='docs/doc[@for="XmlSerializationReader.ReadSerializable"]/*' />
protected IXmlSerializable ReadSerializable(IXmlSerializable serializable) {
serializable.ReadXml(r);
return serializable;
}
private static string WriteXml(IXmlSerializable obj)
{
var f = Path.GetTempFileName();
//var f = "test.xml";
using (var writer = GetXmlWriter(f))
{
writer.WriteStartElement("root");
obj.WriteXml(writer);
writer.WriteEndElement();
}
return f;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="ComponentCore"/> class.
/// </summary>
/// <param name="createdFrom">
/// The created from.
/// </param>
/// <param name="structureType">
/// The structure type.
/// </param>
/// <param name="annotationType">
/// The annotation type.
/// </param>
/// <param name="textFormat">
/// The text format.
/// </param>
/// <param name="codelistAgency">
/// The codelist agency.
/// </param>
/// <param name="codelistId">
/// The codelist id.
/// </param>
/// <param name="codelistVersion">
/// The codelist version.
/// </param>
/// <param name="conceptSchemeAgency">
/// The concept scheme agency.
/// </param>
/// <param name="conceptSchemeId">
/// The concept scheme id.
/// </param>
/// <param name="conceptSchemeVersion">
/// The concept scheme version.
/// </param>
/// <param name="conceptAgency">
/// The concept agency.
/// </param>
/// <param name="conceptId">
/// The concept id.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
protected internal ComponentCore(
IXmlSerializable createdFrom,
SdmxStructureType structureType,
AnnotationsType annotationType,
TextFormatType textFormat,
string codelistAgency,
string codelistId,
string codelistVersion,
string conceptSchemeAgency,
string conceptSchemeId,
string conceptSchemeVersion,
string conceptAgency,
string conceptId,
IIdentifiableObject parent)
: base(createdFrom, structureType, conceptId, null, annotationType, parent)
{
if (string.IsNullOrWhiteSpace(conceptAgency))
{
conceptAgency = this.MaintainableParent.AgencyId;
}
if (textFormat != null || ObjectUtil.ValidOneString(codelistAgency, codelistId, codelistVersion))
{
if (ObjectUtil.ValidOneString(codelistAgency, codelistId, codelistVersion))
{
if (string.IsNullOrWhiteSpace(codelistAgency))
{
codelistAgency = this.MaintainableParent.AgencyId;
}
}
this.LocalRepresentation = new RepresentationCore(
textFormat, codelistAgency, codelistId, codelistVersion, this);
}
this._conceptRef = ConceptRefUtil.BuildConceptRef(
this, conceptSchemeAgency, conceptSchemeId, conceptSchemeVersion, conceptAgency, conceptId);
this.ValidateComponentAttributes();
}
/// <include file='doc\XmlSerializationWriter.uex' path='docs/doc[@for="XmlSerializationWriter.WriteSerializable1"]/*' />
protected void WriteSerializable(IXmlSerializable serializable, string name, string ns, bool isNullable, bool wrapped) {
if (serializable == null) {
if (isNullable) WriteNullTagLiteral(name, ns);
return;
}
if (wrapped) {
w.WriteStartElement(name, ns);
}
serializable.WriteXml(w);
if (wrapped) {
w.WriteEndElement();
}
}
/// <summary>
/// Create a PUT request that sends an object to the API
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
private HttpWebRequest CreateRequestPUT(Uri uri, IXmlSerializable value = null)
{
HttpWebRequest request = this.CreateRequest(uri, "PUT");
if (value != null)
{
using (StreamWriter writer = new StreamWriter(request.GetRequestStream()))
{
writer.Write(value.ToXmlString());
}
}
else
{
request.ContentLength = 0;
}
return request;
}
