/// <summary>
/// convert the xml representation of this class into the document and metadata properties
/// </summary>
/// <param name="reader"></param>
public void ReadXml(XmlReader reader)
{
// good place for debug logging
try
{
// take the reader, turn into an XmlDocument, then parse out the metadata and documents
XmlDocument xmldoc = new XmlDocument();
xmldoc.LoadXml(reader.ReadOuterXml());
submissionMetadata = xmldoc.SelectSingleNode(@".//*[local-name()='SubmitObjectsRequest']"); // cheating and ignoring namespaces
if (submissionMetadata == null)
{
// good place for debug logging
throw new Exception("P&RRequestXDSB Reader cannot find SubmitObjectsRequest");
}
XmlNodeList theDocs = xmldoc.SelectNodes(@".//*[local-name()='Document']");
if (theDocs == null)
{
// good place for debug logging
throw new Exception("P&RRequestXDSB Reader cannot find Document");
}
foreach (XmlNode aDoc in theDocs)
{
SubmissionDocument theDoc = new SubmissionDocument();
theDoc.documentID = aDoc.Attributes["id"].Value.ToString();
theDoc.documentText = Convert.FromBase64String(aDoc.InnerText);
submissionDocuments.Add(theDoc);
}
}
catch (Exception ex)
{
// good place for debug logging
throw ex;
}
// good place for debug logging
}
private Ingestion DeserializeMetadatasets(System.Xml.XmlReader reader)
{
while (reader.Read())
{
if (reader.IsStartElement())
{
if (reader.Name == "metadata-set")
{
string strGuid = reader.GetAttribute("guid");
CFMetadataSet set = new CFMetadataSet();
set.Content = reader.ReadOuterXml();
set.Guid = strGuid;
set.MappedGuid = strGuid;
MetadataSets.Add(set);
}
else
{
throw new FormatException("Invalid XML element: " + reader.Name);
}
}
if (reader.NodeType == System.Xml.XmlNodeType.EndElement)
{
if (reader.Name == "metadata-sets")
{
return(this);
}
}
}
return(this);
}
private XElement CreateVehicleInfoChildElement(XmlReader reader)
{
XElement vehInfoElement = new XElement(DataLoadConstants.ELEMENT_VEHILCEINFO);
XElement regIDElement = new XElement(XDocument.Parse(reader.ReadOuterXml()).Root);
vehInfoElement.Add(regIDElement);
return vehInfoElement;
}
private static EndpointAddress ReadFrom (System.ServiceModel.Channels.AddressingVersion addressingVersion, XmlReader xreader)
{
string xml = xreader.ReadOuterXml ();
StringReader sreader = new StringReader (xml);
XmlReader reader = XmlReader.Create (sreader);
Uri uri = null;
EndpointIdentity identity = null;
reader.MoveToContent ();
List<AddressHeader> header = new List<AddressHeader> ();
while (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) {
if (reader.LocalName == "EndpointReference") {
reader.Read ();
} else if (reader.LocalName == "Address" &&
reader.NodeType == XmlNodeType.Element &&
!reader.IsEmptyElement)
uri = new Uri (reader.ReadElementContentAsString ());
else if (reader.LocalName == "Identity" &&
reader.NodeType == XmlNodeType.Element &&
!reader.IsEmptyElement) {
//How can key re-empact Identity
identity = new X509CertificateEndpointIdentity (new System.Security.Cryptography.X509Certificates.X509Certificate2 ("powershell.pfx", "mono"));
break;
} else {
var headerName = reader.LocalName;
var headerNamespace = reader.NamespaceURI;
reader.MoveToContent ();
reader.ReadStartElement ();
var obj = reader.ReadElementContentAs (GetTypeFromLocalName (reader.LocalName), new XmlNamespaceManager (reader.NameTable));
header.Add (AddressHeader.CreateAddressHeader (headerName, headerNamespace, obj));
reader.MoveToContent ();
reader.ReadEndElement ();
}
}
return identity == null ? new EndpointAddress(uri, header.ToArray ()) : new EndpointAddress(uri, identity, header.ToArray ());
}
/// <summary>
/// Executes an XMLA command on the tabular model for the connection.
/// </summary>
/// <param name="server"></param>
/// <param name="commandStatement"></param>
/// <returns>XmlNodeList containing results of the command execution.</returns>
public static XmlNodeList ExecuteXmlaCommand(Microsoft.AnalysisServices.Core.Server server, string catalog, string commandStatement, ref bool foundFault)
{
XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined);
WriteSoapEnvelopeWithCommandStatement(xmlWriter, server.SessionID, catalog, commandStatement);
System.Xml.XmlReader xmlReader = server.EndXmlaRequest();
xmlReader.MoveToContent();
string fullEnvelopeResponseFromServer = xmlReader.ReadOuterXml();
xmlReader.Close();
XmlDocument documentResponse = new XmlDocument();
documentResponse.LoadXml(fullEnvelopeResponseFromServer);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(documentResponse.NameTable);
nsmgr.AddNamespace("myns1", "urn:schemas-microsoft-com:xml-analysis");
nsmgr.AddNamespace("myns2", "urn:schemas-microsoft-com:xml-analysis:rowset");
XmlNodeList rows = documentResponse.SelectNodes("//myns1:ExecuteResponse/myns1:return/myns2:root/myns2:row", nsmgr);
if (rows.Count == 0 && documentResponse.GetElementsByTagName("faultcode").Count > 0)
{
foundFault = true;
}
return(rows);
}
internal BasicFileElement(System.Xml.XmlReader reader)
: base(reader)
{
FilePath = reader.GetNonEmptyAttribute("Path");
String soundType = reader.GetNonEmptyAttribute("SoundType");
SoundFileType = soundType == "Music" ? SoundFileType.Music : SoundFileType.SoundEffect;
if (reader.IsEmptyElement)
{
reader.Read();
}
else
{
reader.Read();
while (reader.IsStartElement())
{
if (reader.IsStartElement("Effects"))
{
m_Effects = new Effects(reader);
}
else
{
reader.ReadOuterXml();
}
}
reader.ReadEndElement();
}
if (m_Effects == null)
{
m_Effects = new Effects();
}
}
public void ReadXml(System.Xml.XmlReader xreader)
{
MachineValues = new List <DeviceInfo>();
var xml = xreader.ReadOuterXml();
var xdoc = new XmlDocument();
xdoc.LoadXml(xml);
var machineNode = xdoc.SelectSingleNode("//machinevalues");
for (int i = 0; i < machineNode.ChildNodes.Count; i += 3)
{
var di = new DeviceInfo();
var nameNode = machineNode.ChildNodes[i];
var typeNode = machineNode.ChildNodes[i + 1];
var valueNode = machineNode.ChildNodes[i + 2];
di.Name = nameNode.InnerText;
di.Type = (DeviceType)int.Parse(typeNode.InnerText);
di.Value = valueNode.InnerText;
MachineValues.Add(di);
}
var tokenNode = xdoc.SelectSingleNode("//token");
this.Token = tokenNode.InnerText;
}
/// <summary>
/// Reads XML from the configuration file.
/// </summary>
/// <param name="xmlReader">The XmlReader object, which reads from the configuration file.</param>
protected internal override void DeserializeSection(XmlReader xmlReader)
{
if (RawXml == null)
RawXml = xmlReader.ReadOuterXml();
else
xmlReader.Skip();
}
private void parseXml(int menu)
{
menuItems = new List <SideNavigationItem>();
try {
System.Xml.XmlReader reader = Resources.GetXml(menu);
var sb = new System.Text.StringBuilder();
while (reader.Read())
{
sb.AppendLine(reader.ReadOuterXml());
}
XmlDocument document = new XmlDocument();
document.LoadXml(sb.ToString());
foreach (XmlNode node in document.GetElementsByTagName("item"))
{
string textId = node.Attributes["title", "http://schemas.android.com/apk/res/android"].Value;
string iconId = node.Attributes["icon", "http://schemas.android.com/apk/res/android"].Value;
string resId = node.Attributes["id", "http://schemas.android.com/apk/res/android"].Value;
SideNavigationItem item = new SideNavigationItem();
item.id = int.Parse(resId.Replace("@", ""));
item.text = resourceIdToString(textId);
item.icon = int.Parse(iconId.Replace("@", ""));
menuItems.Add(item);
}
} catch (Exception e) {
Log.Warn(LOG_TAG, e);
}
}
public void ReadXml(XmlReader reader)
{
var s = reader.ReadOuterXml();
var x = XDocument.Parse(s);
if (x.Root == null) return;
foreach (var e in x.Root.Elements())
{
var name = e.Name.ToString();
switch (name)
{
case "List":
foreach (var ee in e.Elements())
_list.Add(Util.DeSerialize<OnlineRegPersonModel>(ee.ToString()));
break;
case "History":
foreach (var ee in e.Elements())
_history.Add(ee.Value);
break;
default:
Util.SetPropertyFromText(this, name, e.Value);
break;
}
}
}
/// <summary>
/// Implements a custom deserialization of the <see cref="DataModelMap"/> value.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
protected override DataModelMap DeserializeValue(System.Xml.XmlReader reader)
{
var xml = reader.ReadOuterXml();
var xs = new XmlSerialized <DataModelMap>(xml);
return(xs.Deserialize());
}
protected internal override void DeserializeSection(XmlReader xmlReader) {
if (!xmlReader.Read() || xmlReader.NodeType != XmlNodeType.Element) {
throw new ConfigurationErrorsException(SR.GetString(SR.Config_base_expected_to_find_element), xmlReader);
}
_rawXml = xmlReader.ReadOuterXml();
_isModified = true;
}
public static object Deserialize(Type type, XmlReader reader, bool readInnerXml)
{
if (null == type) throw new ArgumentNullException("type");
if (null == reader) throw new ArgumentNullException("reader");
if (reader.NodeType != XmlNodeType.Element) throw new ArgumentException("reader is not positioned on an element");
object value = null;
StringBuilder serializationBuilder = new StringBuilder();
serializationBuilder.Append("<?xml version=\"1.0\"?>");
if (readInnerXml)
{
serializationBuilder.AppendLine(reader.ReadInnerXml());
}
else
{
serializationBuilder.AppendLine(reader.ReadOuterXml());
}
string serialization = serializationBuilder.ToString();
using (StringReader stringReader = new StringReader(serialization))
{
XmlSerializer serializer = new XmlSerializer(type);
value = serializer.Deserialize(stringReader);
}
return value;
}
public void ReadXml(XmlReader reader)
{
int sequenceCount = 0;
bool isEmpty = reader.IsEmptyElement;
reader.ReadStartElement();
if (isEmpty)
return;
while (reader.NodeType == XmlNodeType.Element)
{
if (sequenceCount == 0 || reader.IsStartElement("title"))
{
PitchSequences.Add(new PitchSequence());
sequenceCount++;
}
if (reader.IsStartElement("title"))
PitchSequences[sequenceCount - 1].Title = reader.ReadElementString();
else if (reader.IsStartElement("pitch"))
{
var pitch = new Pitch();
pitch.ReadXml(reader);
PitchSequences[sequenceCount - 1].Pitches.Add(pitch);
}
else
reader.ReadOuterXml();
}
reader.ReadEndElement();
}
public Searchers(XmlReader reader)
{
this.Choices = new List<Choice>();
this.CurrentSearch = "";
reader.Read();
if (reader.Name != "TheSearchers")
return; // bail out
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == "TheSearchers") && !reader.IsStartElement())
break; // all done
if (reader.Name == "Current")
this.CurrentSearch = reader.ReadElementContentAsString();
else if (reader.Name == "Choice")
{
string url = reader.GetAttribute("URL");
if (url == null)
url = reader.GetAttribute("URL2");
else
{
// old-style URL, replace "!" with "{ShowName}+{Season}+{Episode}"
url = url.Replace("!", "{ShowName}+{Season}+{Episode}");
}
this.Add(reader.GetAttribute("Name"), url);
reader.ReadElementContentAsString();
}
else
reader.ReadOuterXml();
}
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
var empty = reader.IsEmptyElement;
reader.ReadStartElement();
if (!empty)
{
while (reader.MoveToContent() == XmlNodeType.Element)
{
if (reader.Name == @"ProductName" && !reader.IsEmptyElement)
{
ProductName = reader.ReadElementString();
}
else if (reader.Name == @"GlyphColor" && !reader.IsEmptyElement)
{
GlyphColor = ParseColor(reader.ReadElementString());
}
else
{
// consume the bad element and skip to next sibling or the parent end element tag
reader.ReadOuterXml();
}
}
reader.MoveToContent();
reader.ReadEndElement();
}
}
public override object Deserialize(System.Xml.XmlReader reader, SerializationContext state)
{
var document = new XmlDocument();
document.LoadXml(reader.ReadOuterXml());
return(document.FirstChild);
}
private string ReadOuterXml(XmlReader forReader) {
try {
forReader.MoveToContent();
return forReader.ReadOuterXml();
} finally {
forReader.Close();
}
}
public void ReadXml(XmlReader reader)
{
var s = reader.ReadOuterXml();
var x = XDocument.Parse(s);
if (x.Root == null) return;
eqset = 0;
txset = 0;
menuset = 0;
foreach (var e in x.Root.Elements())
{
var name = e.Name.ToString();
switch (name)
{
case "FundItem":
ReadFundItem(e);
break;
case "FamilyAttend":
ReadFamilyAttend(e);
break;
case "ExtraQuestion":
ReadExtraQuestion(e);
break;
case "Text":
ReadText(e);
break;
case "YesNoQuestion":
ReadYesNoChoices(e);
break;
case "option":
ReadDropdownOption(e);
break;
case "Checkbox":
ReadCheckboxChoice(e);
break;
case "MenuItem":
ReadMenuItemChoice(e);
break;
case "MissionTripGoerId":
MissionTripGoerId = e.Value.ToInt();
break;
case "CreatingAccount":
CreatingAccount = e.Value.ToBool();
break;
case "SpecialTest":
ReadSpecialTest(e);
break;
default:
if (Util.SetPropertyFromText(this, TranslateName(name), e.Value) == false)
{
ErrorSignal.FromCurrentContext().Raise(new Exception("OnlineRegPerson Missing name:" + name));
Log($"Error:Missing({name})");
}
break;
}
}
}
protected override void DeserializeSection(XmlReader reader)
{
if (!reader.Read() || (reader.NodeType != XmlNodeType.Element))
{
throw new ConfigurationErrorsException("Expected to find element");
}
_rawXml = reader.ReadOuterXml();
}
private static string RequiredAttribute(XmlReader reader, string attribute)
{
string result = OptionalAttribute(reader, attribute);
if(result == null)
{
throw Error.CouldNotFindRequiredAttribute(attribute, reader.ReadOuterXml());
}
return result;
}
/// <summary>
/// Gets a value indicating whether an unknown element is encountered during deserialization.
/// </summary>
/// <param name="elementName">The name of the unknown subelement.</param>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> being used for deserialization.</param>
/// <returns>
/// true when an unknown element is encountered while deserializing; otherwise, false.
/// </returns>
/// <exception cref="T:System.Configuration.ConfigurationErrorsException">The element identified by <paramref name="elementName"/> is locked.- or -One or more of the element's attributes is locked.- or -<paramref name="elementName"/> is unrecognized, or the element has an unrecognized attribute.- or -The element has a Boolean attribute with an invalid value.- or -An attempt was made to deserialize a property more than once.- or -An attempt was made to deserialize a property that is not a valid member of the element.- or -The element cannot contain a CDATA or text element.</exception>
protected override bool OnDeserializeUnrecognizedElement(string elementName, System.Xml.XmlReader reader)
{
if (OptionElements == null)
{
OptionElements = new NameValueCollection();
}
OptionElements.Add(elementName, reader.ReadOuterXml());
return(true);
}
public virtual void ReadXml(System.Xml.XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
string deserializedXmlString = reader.ReadOuterXml();
mUserPropertiesDictionary = StringToUserPropertyDictionary(deserializedXmlString);
}
private void ProcessDataReader(XmlReader reader)
{
ResultsListBox.Items.Clear();
while (reader.Read())
{
ResultsListBox.Items.Add(reader.ReadOuterXml());
//MessageBox.Show(reader.ReadOuterXml());
}
reader.Close();
}
protected override void InitializeElementProperties(System.Xml.XmlReader reader, ref object obj, ITypeSerializationInfo info, XmlSerializationContext context)
{
int currentDepth = reader.Depth;
while (reader.Depth < currentDepth || reader.Read())
{
if (reader.Depth == currentDepth)
{
break;
}
else if (reader.Depth < currentDepth)
{
return;
}
if (reader.NodeType == XmlNodeType.Element)
{
var found = false;
foreach (IPropertySerializationInfo p in info.ElementProperties)
{
if (IsPropertyElement(reader, p))
{
ReadElementFromProperty(reader, obj, context, p);
found = true;
break;
}
}
if (!found)
{
foreach (IPropertySerializationInfo p in info.AttributeProperties)
{
if (IsPropertyElement(reader, p))
{
ReadElementFromProperty(reader, obj, context, p);
found = true;
break;
}
}
if (!found)
{
OnUnknownElement(new UnknownElementEventArgs(obj, reader.ReadOuterXml()));
}
}
}
else if ((reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA))
{
if (info.DefaultProperty == null)
{
throw new InvalidOperationException("Simple content unexpected for type " + info.Type.FullName);
}
InitializePropertyFromText(info.DefaultProperty, obj, reader.Value, context);
}
}
}
protected override bool OnDeserializeUnrecognizedElement(string elementName, System.Xml.XmlReader reader)
{
if (OptionElements == null)
{
OptionElements = new NameValueCollection();
}
//Because ConfigurationElement.DeserializeElemenet() method only accept outerXml and in MS.NET, it accept innerXml,
//so there is a hack over here
OptionElements.Add(elementName, Platform.IsMono ? reader.ReadOuterXml() : reader.ReadInnerXml());
return(true);
}
public override void DeserializeSection (XmlReader xmlReader)
{
// not sure if it is the right thing to do,
// but DefaultSection does not raise errors on
// unrecognized contents.
// FIXME: it is nothing more than hack: RawXml should
// not be set more than once.
if (RawXml == null)
RawXml = xmlReader.ReadOuterXml ();
else
xmlReader.Skip ();
}
static KeyValuePair<string, MethodBase> DeserializeMethodBase(XmlReader reader)
{
var sb = new StringBuilder();
sb.Append(reader.ReadOuterXml());
var s = sb.ToString();
var ndcs = new NetDataContractSerializer();
using (var sr = new StringReader(s))
using (var xr = new XmlTextReader(sr))
{
return new KeyValuePair<string, MethodBase>(s, (MethodBase)ndcs.ReadObject(xr));
}
}
protected override void DeserializeElement( XmlReader reader, bool serializeCollectionKey )
{
elementXml = new XmlDocument();
elementXml.LoadXml( reader.ReadOuterXml() );
// Create a new XmlTextReader so this element can be loaded
// by the framework.
using ( XmlReader newReader = XmlDictionaryReader.CreateTextReader( Encoding.UTF8.GetBytes( elementXml.DocumentElement.OuterXml ), XmlDictionaryReaderQuotas.Max ) )
{
newReader.Read();
base.DeserializeElement( newReader, serializeCollectionKey );
}
}
public void ReadXml(XmlReader reader)
{
if (reader.Name() == ItemElementName)
{
_mode = EnumerationMode.EnumerateObjectAndEPR;
reader.ReadStartElement(ItemElementName);
_rawValue = reader.ReadOuterXml();
}
_eprValue = new EndpointReference();
_eprValue.ReadOuterXml(reader);
if (IncludeObject())
{
reader.ReadEndElement();
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
var localName = reader.Name;
this.Content = reader.ReadOuterXml();
return;
//return;
//while (reader.Read())
//{
// if (reader.Name == localName && reader.NodeType == XmlNodeType.EndElement)
// {
// reader.Read();
// break;
// }
//}
}
public void ReadXml(XmlReader reader) {
reader.ReadToFollowing("TypeName");
reader.ReadStartElement("TypeName");
TypeName=reader.ReadString();
reader.ReadEndElement();//TypeName
while(reader.NodeType!=XmlNodeType.Element) {
reader.Read();//gets rid of whitespace if in debug mode.
}
reader.ReadStartElement("Obj");
while(reader.NodeType!=XmlNodeType.Element) {
reader.Read();
}
string strObj=reader.ReadOuterXml();
//now get the reader to the correct location
while(reader.NodeType!=XmlNodeType.EndElement) {
reader.Read();
}
reader.ReadEndElement();//Obj
while(reader.NodeType!=XmlNodeType.EndElement) {
reader.Read();
}
reader.ReadEndElement();//DtoObject
Type type=null;
if(TypeName.StartsWith("List<")) {
Type typeGen=Type.GetType(TypeName.Substring(5,TypeName.Length-6));
Type typeList=typeof(List<>);
type=typeList.MakeGenericType(typeGen);
}
else if(TypeName=="System.Drawing.Color") {
type=typeof(int);
}
else {
//This works fine for non-system types as well without specifying the assembly,
//because we are already in the OpenDentBusiness assembly.
type=Type.GetType(TypeName);
}
XmlSerializer serializer = new XmlSerializer(type);
//XmlReader reader2=XmlReader.Create(new StringReader(strObj));
XmlTextReader reader2=new XmlTextReader(new StringReader(strObj));
if(TypeName=="System.Drawing.Color") {
Obj=Color.FromArgb((int)serializer.Deserialize(reader2));
}
else {
Obj=serializer.Deserialize(reader2);
}
//Convert.ChangeType(serializer.Deserialize(reader2),type);
}
/// <summary>
/// To get output in xml format for the provided DB key connection.
/// </summary>
/// <param name="strProcName"></param>
/// <param name="htable"></param>
/// /// <param name="strDBKey"></param>
/// <returns>string</returns>
public string GetOutputXML(string strProcName, Hashtable htable, string strDBKey)
{
try
{
//track database activity
TrackDBACtivity(strProcName, htable);
string strXML = "";
objCon = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConn"].ConnectionString);
if (objCon.State != ConnectionState.Open)
{
objCon.Open();
}
objCom = new SqlCommand();
objCom.CommandText = strProcName;
objCom.CommandType = CommandType.StoredProcedure;
objCom.Connection = objCon;
foreach (DictionaryEntry dist in htable)
{
objCom.Parameters.AddWithValue((string)dist.Key, dist.Value);
}
//objCon.Open();
// SqlDataReader objDtReader = objCom.ExecuteReader(CommandBehavior.CloseConnection);
System.Xml.XmlReader objXMLReader = objCom.ExecuteXmlReader();
while (objXMLReader.Read())
{
strXML = strXML + objXMLReader.ReadOuterXml();
}
//update executed records against current activity
UpdateDBACtivity(!string.IsNullOrEmpty(strXML) ? 1 : 0);
return(strXML);
}
catch (Exception ex)
{
throw ex;
}
finally
{
objCon.Close();
}
}
protected override void DeserializeElement(System.Xml.XmlReader reader, bool serializeCollectionKey)
{
var outxml = reader.ReadOuterXml();
var ele = XElement.Parse(outxml);
foreach (var e in ele.Elements())
{
if (e.Name == "add")
{
var keyAttr = e.Attribute("key");
var valueAttr = e.Attribute("value");
string key = null, value = null;
if (keyAttr != null)
{
key = keyAttr.Value;
}
if (valueAttr != null)
{
value = valueAttr.Value;
}
if (key != null)
{
this.data.Add(key, value);
}
}
else if (e.Name == "remove")
{
string key = null;
var keyAttr = e.Attribute("key");
if (keyAttr != null)
{
key = keyAttr.Value;
}
if (key != null)
{
this.data.Remove(key);
}
}
}
}
protected override void InitializeElementProperties(System.Xml.XmlReader reader, ref object obj, ITypeSerializationInfo info, XmlSerializationContext context)
{
int currentDepth = reader.Depth;
while (reader.Depth < currentDepth || reader.Read())
{
if (reader.Depth == currentDepth)
{
break;
}
else if (reader.Depth < currentDepth)
{
return;
}
if (reader.NodeType == XmlNodeType.Element)
{
var found = false;
foreach (IPropertySerializationInfo p in info.ElementProperties)
{
if (IsPropertyElement(reader, p))
{
ReadElementFromProperty(reader, obj, context, p);
found = true;
break;
}
}
if (!found)
{
foreach (IPropertySerializationInfo p in info.AttributeProperties)
{
if (IsPropertyElement(reader, p))
{
ReadElementFromProperty(reader, obj, context, p);
found = true;
break;
}
}
if (!found)
{
OnUnknownElement(new UnknownElementEventArgs(obj, reader.ReadOuterXml()));
}
}
}
}
}
public void ReadXml(XmlReader reader) {
reader.ReadToFollowing("TypeName");
reader.ReadStartElement("TypeName");
TypeName=reader.ReadString();
reader.ReadEndElement();//TypeName
while(reader.NodeType!=XmlNodeType.Element) {
reader.Read();//gets rid of whitespace if in debug mode.
}
reader.ReadStartElement("Obj");
while(reader.NodeType!=XmlNodeType.Element) {
reader.Read();
}
string strObj=reader.ReadOuterXml();
//now get the reader to the correct location
while(reader.NodeType!=XmlNodeType.EndElement) {
reader.Read();
}
reader.ReadEndElement();//Obj
while(reader.NodeType!=XmlNodeType.EndElement) {
reader.Read();
}
reader.ReadEndElement();//DtoObject
//Now, process what we read.
Type type=null;
if(TypeName=="System.Drawing.Color") {
type=typeof(int);
}
else{
type=ConvertNameToType(TypeName);
}
XmlSerializer serializer = new XmlSerializer(type);
//XmlReader reader2=XmlReader.Create(new StringReader(strObj));
XmlTextReader reader2=new XmlTextReader(new StringReader(strObj));
if(TypeName=="System.Drawing.Color") {
Obj=Color.FromArgb((int)serializer.Deserialize(reader2));
}
else {
Obj=serializer.Deserialize(reader2);
}
//Convert.ChangeType(serializer.Deserialize(reader2),type);
}
public void ReadXml(XmlReader reader)
{
bool isEmpty = reader.IsEmptyElement;
reader.ReadStartElement();
if (isEmpty)
return;
while (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.Text)
{
if (reader.NodeType == XmlNodeType.Text)
Spans.Add(new Span { SpanType = SpanType.Text, Text = reader.ReadContentAsString() });
else if (reader.IsStartElement("offroute"))
Spans.Add(new Span { SpanType = SpanType.OffRoute, Text = reader.ReadElementString() });
else if (reader.IsStartElement("sump"))
Spans.Add(new Span { SpanType = SpanType.Sump, Text = reader.ReadElementString() });
else if (reader.IsStartElement("sup"))
throw new NotSupportedException("<sup> tag is not supported");
else
reader.ReadOuterXml();
}
reader.ReadEndElement();
}
/// <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>
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.IsEmptyElement)
{
return;
}
var type = GetType();
reader.MoveToContent();
var nodeContent = reader.ReadOuterXml();
var document = XElement.Parse(nodeContent);
if (document == null)
{
Log.Error("Cannot retrieve xml document from the xml reader for type '{0}'", type.FullName);
return;
}
var serializer = SerializationFactory.GetXmlSerializer();
serializer.Deserialize(this, new XmlSerializationContextInfo(document, this));
}
public ShowRule(XmlReader reader)
{
this.SetToDefaults();
reader.Read();
while (reader.Name != "Rule")
return;
reader.Read();
while (reader.Name != "Rule")
{
if (reader.Name == "DoWhatNow")
this.DoWhatNow = (RuleAction) reader.ReadElementContentAsInt();
else if (reader.Name == "First")
this.First = reader.ReadElementContentAsInt();
else if (reader.Name == "Second")
this.Second = reader.ReadElementContentAsInt();
else if (reader.Name == "Text")
this.UserSuppliedText = reader.ReadElementContentAsString();
else
reader.ReadOuterXml();
}
}
public void ReadXml(XmlReader reader)
{
bool isEmpty = reader.IsEmptyElement;
reader.ReadStartElement();
if (isEmpty)
return;
while (reader.NodeType == XmlNodeType.Element)
{
if (reader.IsStartElement("p"))
{
var para = new Para();
para.ReadXml(reader);
Parts.Add(para);
}
else if (reader.IsStartElement("subheader"))
{
var subHeader = new SubHeader(1);
subHeader.ReadXml(reader);
Parts.Add(subHeader);
}
else if (reader.IsStartElement("subheader2"))
{
var subHeader = new SubHeader(2);
subHeader.ReadXml(reader);
Parts.Add(subHeader);
}
else if (reader.IsStartElement("pitches"))
{
var pitches = new Pitches();
pitches.ReadXml(reader);
Parts.Add(pitches);
}
else
reader.ReadOuterXml();
}
reader.ReadEndElement();
}
public void ReadXml(XmlReader reader)
{
var root = XElement.Parse(reader.ReadOuterXml());
this.IsMaximised = (bool)root.Element("IsMaximised");
// Lovely little backwards-compat issue, because I screwed up...
// We used to read/write in a culture-specific format (oops), then that was changed to culture-invariant
// Now we need to handle parsing both.
// Use 'minPosition' as the sample, but this test could apply to any
var minPosition = root.Element("MinPosition").Value;
if (minPosition.Contains(','))
{
this.MinPosition = (Point)pointConverter.ConvertFromInvariantString(root.Element("MinPosition").Value);
this.MaxPosition = (Point)pointConverter.ConvertFromInvariantString(root.Element("MaxPosition").Value);
this.NormalPosition = (Rectangle)rectangleConverter.ConvertFromInvariantString(root.Element("NormalPosition").Value);
}
else
{
this.MinPosition = (Point)pointConverter.ConvertFrom(root.Element("MinPosition").Value);
this.MaxPosition = (Point)pointConverter.ConvertFrom(root.Element("MaxPosition").Value);
this.NormalPosition = (Rectangle)rectangleConverter.ConvertFrom(root.Element("NormalPosition").Value);
}
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The XmlReader stream from which the object is deserialized.</param>
public void ReadXml(System.Xml.XmlReader reader)
{
this.Clear();
XmlSerializer xs = new XmlSerializer(typeof(object));
reader.ReadStartElement(_rootElementName);
while (reader.NodeType != XmlNodeType.EndElement)
{
string value = reader.GetAttribute(_keyAttributeName);
reader.ReadStartElement(_entryElementName);
string xml = reader.ReadOuterXml();
if (!String.IsNullOrEmpty(value))
{
StringReader sr = new StringReader(xml);
XmlTextReader xr = new XmlTextReader(sr);
object o = xs.Deserialize(xr);
this.Add(value, o);
}
reader.ReadEndElement();
}
reader.ReadEndElement();
}
public static List<string> ReadStringsFromXml(XmlReader reader, string elementName, string stringName)
{
List<string> r = new List<String>();
if (reader.Name != elementName)
return r; // uhoh
if (!reader.IsEmptyElement)
{
reader.Read();
while (!reader.EOF)
{
if ((reader.Name == elementName) && !reader.IsStartElement())
break;
if (reader.Name == stringName)
r.Add(reader.ReadElementContentAsString());
else
reader.ReadOuterXml();
}
}
reader.Read();
return r;
}
/// <summary>
/// To get output in xml format for default connection.
/// </summary>
/// <param name="strProcName"></param>
/// <param name="strDBKey"></param>
/// <returns>string</returns>
public string GetOutputXML(string strProcName, string strDBKey)
{
try
{
//track database activity
TrackDBACtivity(strProcName, null);
string strXML = "";
objCon = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConn"].ConnectionString);
if (objCon.State != ConnectionState.Open)
{
objCon.Open();
}
objCom = new SqlCommand(strProcName, objCon);
objCom.CommandType = CommandType.StoredProcedure;
System.Xml.XmlReader objXMLReader = objCom.ExecuteXmlReader();
while (objXMLReader.Read())
{
strXML = strXML + objXMLReader.ReadOuterXml();
}
//update executed records against current activity
UpdateDBACtivity(!string.IsNullOrEmpty(strXML) ? 1 : 0);
return(strXML);
}
catch (Exception ex)
{
throw ex;
}
finally
{
objCon.Close();
}
}
//public static UIElement cloneElement(UIElement orig)
//{
// if (orig == null)
// return (null);
// string s = XamlWriter.Save(orig);
// StringReader stringReader = new StringReader(s);
// XmlReader xmlReader = XmlTextReader.Create(stringReader, new XmlReaderSettings());
// return (UIElement)XamlReader.Load(xmlReader);
//}
////dll reference to System.Runtime.Serialization
//public static T DeepCopy<T>(this T oSource)
//{
// T oClone;
// System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(typeof(T));
// using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
// {
// dcs.WriteObject(ms, oSource);
// ms.Position = 0;
// oClone = (T)dcs.ReadObject(ms);
// }
// return oClone;
//}
public static List <UIElement> LoadXamlFromStream(System.IO.Stream s)
{
List <UIElement> listEles = new List <UIElement>();
System.Xml.XmlReader reader = System.Xml.XmlReader.Create(s);
//if (reader.Name == "Items")
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name != "Items")
{
//MessageBox.Show(reader.ReadOuterXml());
if (reader.Name == "SilverlightControl1")
{
//Type calcType = testAssembly.GetType("Test.Calculator");
//// create instance of class Calculator
//object calcInstance = Activator.CreateInstance(calcType);
//// Load a particular assembly from the XAP package
//Assembly a = GetAssemblyFromPackage(assemblyName, e.Result);
//// Get an instance of the XAML object
//object page = a.CreateInstance(className);
}
else
{
listEles.Add(System.Windows.Markup.XamlReader.Load(reader.ReadOuterXml()) as UIElement);
}
}
}
}
return(listEles);
}
public void ReadXml(XmlReader reader)
{
reader.MoveToContent();
var empty = reader.IsEmptyElement;
reader.ReadStartElement();
if (!empty)
{
while (reader.MoveToContent() == XmlNodeType.Element)
{
switch (reader.Name)
{
case _propertyVisible:
Visible = ReadXmlBooleanAttribute(reader, false);
break;
default:
// consume the bad element and skip to next sibling or the parent end element tag
reader.ReadOuterXml();
break;
}
}
reader.MoveToContent();
reader.ReadEndElement();
}
}
public async Task <HttpResponseMessage> PostRawBufferManual()
{
string connStr = "";
string loc = "";
try
{
string request = await Request.Content.ReadAsStringAsync();
var addin = Globals.ThisAddIn;
var app = addin.Application;
var wb = app.ActiveWorkbook;
loc = wb.FullName; //@"D:\Data\Presentations\Drop Your DAX\demos\02 DAX filter similar.xlsx";
// parse request looking for workbook name in Workstation ID
// we are using the Workstation ID property to tunnel the location property through
// from the UI to the PowerPivot engine. The Location property does not appear to get
// serialized through into the XMLA request so we "hijack" the Workstation ID
var wsid = ParseRequestForWorkstationID(request);
if (!string.IsNullOrEmpty(wsid))
{
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "Resetting Location based on WorkstationID to: " + loc);
loc = wsid;
}
connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location=\"{0}\"", loc);
//connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location={0}", loc);
// 2010 conn str
//connStr = string.Format("Provider=MSOLAP.5;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Cell Error Mode=TextValue;Location={0}", loc);
//connStr = string.Format("Provider=MSOLAP;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Location={0};", loc);
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "About to Load AmoWrapper");
AmoWrapper.AmoType amoType = AmoWrapper.AmoType.AnalysisServices;
if (float.Parse(app.Version, CultureInfo.InvariantCulture) >= EXCEL_2013)
{
amoType = AmoWrapper.AmoType.Excel;
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "Loading Microsoft.Excel.Amo");
}
else
{
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "defaulting to Microsoft.AnalysisServices");
}
var svr = new AmoWrapper.AmoServer(amoType);
svr.Connect(connStr);
// STEP 1: send the request to server.
Log.Verbose("{class} {method} request: {request}", "XmlaController", "PostRawBufferManual", request);
System.IO.TextReader streamWithXmlaRequest = new StringReader(request);
System.Xml.XmlReader xmlaResponseFromServer = null; // will be used to parse the XML/A response from server
string fullEnvelopeResponseFromServer = "";
try
{
//xmlaResponseFromServer = svr.SendXmlaRequest( XmlaRequestType.Undefined, streamWithXmlaRequest);
xmlaResponseFromServer = svr.SendXmlaRequest(streamWithXmlaRequest);
// STEP 2: read/parse the XML/A response from server.
xmlaResponseFromServer.MoveToContent();
fullEnvelopeResponseFromServer = xmlaResponseFromServer.ReadOuterXml();
}
catch (Exception ex)
{
Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex);
//result = new HttpResponseMessage(HttpStatusCode.InternalServerError);
//result.Content = new StringContent(String.Format("An unexpected error occurred (sending XMLA request): \n{0}", ex.Message));
}
finally
{
streamWithXmlaRequest.Close();
}
HttpResponseMessage result;
try
{
result = new HttpResponseMessage(HttpStatusCode.OK);
result.Content = new StringContent(fullEnvelopeResponseFromServer);
result.Content.Headers.ContentType = new MediaTypeHeaderValue("text/xml");
result.Headers.TransferEncodingChunked = true;
}
catch (Exception ex)
{
Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex);
result = new HttpResponseMessage(HttpStatusCode.InternalServerError);
result.Content = new StringContent(String.Format("An unexpected error occurred (reading XMLA response): \n{0}", ex.Message));
}
finally
{
// STEP 3: close the System.Xml.XmlReader, to release the connection for future use.
if (xmlaResponseFromServer != null)
{
xmlaResponseFromServer.Close();
}
}
return(result);
}
catch (Exception ex)
{
Log.Error("ERROR Connecting: {class} {method} loc: '{loc}' conn:'{connStr}' ex: {exception}", "XmlaController", "PostRawBufferManual", loc, connStr, ex);
var expResult = new HttpResponseMessage(HttpStatusCode.InternalServerError);
expResult.Content = new StringContent(String.Format("An unexpected error occurred: \n{0}", ex.Message));
return(expResult);
}
}
protected override void DeserializeElement(System.Xml.XmlReader reader, bool serializeCollectionKey)
{
var xml = reader.ReadOuterXml();
var root = XDocument.Parse(xml).Root?.Element("providers");
if (root == null)
{
return;
}
providers = new List <DataProviderFactoryInfo>();
foreach (var provider in root.Elements())
{
var assembly = provider.Attribute("assembly").Value;
var type = provider.Attribute("type")?.Value;
var providerFactoryType = provider.Attribute("providerFactoryType").Value;
var mappingResource = provider.Attribute("mappingResource");
// if (mappingResource == null)
// throw new Exception("The data access provider configuration needs to specify the mappingResource attribute.");
var mappingDirectory = GetMappingDirectory(provider.Attribute("mappingDirectory"));
var connectionStringKey = string.Empty;
if (provider.Attribute("connectionStringKey") != null)
{
connectionStringKey = provider.Attribute("connectionStringKey").Value;
}
var connectionString = string.Empty;
if (provider.Attribute("connectionString") != null)
{
connectionString = provider.Attribute("connectionString").Value;
}
var providerItem = new DataProviderFactoryInfo
{
AssemblyName = assembly,
TypeName = type,
MappingResource = mappingResource?.Value,
ProviderFactoryType = providerFactoryType,
MappingDirectory = mappingDirectory,
ConnectionStringKey = connectionStringKey,
ConnectionString = connectionString
};
providers.Add(providerItem);
}
// Read sync file:
var syncAttribute = root.Attribute("syncFilePath");
if (syncAttribute != null)
{
SyncFilePath = syncAttribute.Value;
}
// Read file dependancy:
var fileDependancyPathAttribute = root.Attribute("fileDependancyPath");
if (fileDependancyPathAttribute != null)
{
FileDependancyPath = fileDependancyPathAttribute.Value;
}
}
void ITwentyThreeParsable.Load(System.Xml.XmlReader reader)
{
ResponseXml = reader.ReadOuterXml();
}
private Ingestion DeserializeEntityTypes(System.Xml.XmlReader reader)
{
return(DeserializeEntityTypes(XElement.Parse(reader.ReadOuterXml())));
}
public override void ReadXml(System.Xml.XmlReader reader)
{
using (System.Xml.XmlReader subTree = reader.ReadSubtree()) {
subTree.Read();
string tmp = subTree.ReadOuterXml();
//seek for template tag
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read();
base.ReadXml(xr);
}
//process content
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read(); //skip current node
while (!xr.EOF)
{
xr.Read(); //read first child
if (!xr.IsStartElement())
{
continue;
}
if (xr.Name == "Template")
{
xr.Skip();
if (!xr.IsStartElement())
{
continue;
}
}
Type t = Type.GetType("Crow." + xr.Name);
if (t == null)
{
Assembly a = Assembly.GetEntryAssembly();
foreach (Type expT in a.GetExportedTypes())
{
if (expT.Name == xr.Name)
{
t = expT;
}
}
}
if (t == null)
{
throw new Exception(xr.Name + " type not found");
}
GraphicObject go = (GraphicObject)Activator.CreateInstance(t);
(go as IXmlSerializable).ReadXml(xr);
Content = go;
xr.Read(); //closing tag
}
}
}
}
public override string ReadOuterXml()
{
return(reader.ReadOuterXml());
}
public override string ReadOuterXml()
{
CheckAsync();
return(_coreReader.ReadOuterXml());
}
void IFlickrParsable.Load(System.Xml.XmlReader reader)
{
ResponseXml = reader.ReadOuterXml();
}
public Banner(SeriesInfo ser, Season seas, int? codeHint, XmlReader r, CommandLineArgs args)
{
// <Banner>
// <id>708811</id>
// <BannerPath>seasonswide/79488-5.jpg</BannerPath>
// <BannerType>season</BannerType>
// <BannerType2>seasonwide</BannerType2>
// <Language>en</Language>
// <Rating/>
// <RatingCount>0</RatingCount>
// <Season>5</Season>
// blah blah
// </Banner>
try
{
this.SetDefaults(ser, seas);
this.SeriesID = (int) codeHint;
r.Read();
if (r.Name != "Banner")
return;
r.Read();
while (!r.EOF)
{
if ((r.Name == "Banner") && (!r.IsStartElement()))
break;
if (r.Name == "id")
this.BannerId = r.ReadElementContentAsInt();
else if (r.Name == "seriesid")
this.SeriesID = r.ReadElementContentAsInt(); // thetvdb series id
else if (r.Name == "seasonid")
this.SeasonID = r.ReadElementContentAsInt();
else if (r.Name == "BannerPath")
this.BannerPath = XMLHelper.ReadStringFixQuotesAndSpaces(r);
else if (r.Name == "BannerType")
this.BannerType = r.ReadElementContentAsString();
else if (r.Name == "BannerType2")
this.BannerType2 = r.ReadElementContentAsString();
else if (r.Name == "Language")
this.Language = r.ReadElementContentAsString();
else if (r.Name == "Rating")
{
String sn = r.ReadElementContentAsString();
double.TryParse(sn, out this.Rating);
}
else if (r.Name == "RatingCount")
this.RatingCount = r.ReadElementContentAsInt();
else if (r.Name == "Season")
this.SeasonID = r.ReadElementContentAsInt();
else if (r.Name == "Colors") this.Colors = r.ReadElementContentAsString();
else if (r.Name == "ThumbnailPath") this.ThumbnailPath = r.ReadElementContentAsString();
else if (r.Name == "VignettePath") this.VignettePath = r.ReadElementContentAsString();
else if (r.Name == "SeriesName") this.SeriesName = r.ReadElementContentAsString();
else
{
if ((r.IsEmptyElement) || !r.IsStartElement())
r.ReadOuterXml();
else
r.Read();
}
}
}
catch (XmlException e)
{
string message = "Error processing data from TheTVDB for a banner.";
if (this.SeriesID != -1)
message += "\r\nSeries ID: " + this.SeriesID;
if (this.BannerId != -1)
message += "\r\nBanner ID: " + this.BannerId;
if (!string.IsNullOrEmpty(this.BannerPath))
message += "\r\nBanner Path: " + this.BannerPath;
if (!string.IsNullOrEmpty(this.Name))
message += "\r\nName: " + this.Name;
message += "\r\n" + e.Message;
if (!args.Unattended)
MessageBox.Show(message, "TVRename", MessageBoxButtons.OK, MessageBoxIcon.Error);
throw new TVDBException(e.Message);
}
}
private bool LoadWidths(XmlReader xml)
{
string forwho = xml.GetAttribute("For");
ListView lv = this.ListViewByName(forwho);
if (lv == null)
{
xml.ReadOuterXml();
return true;
}
xml.Read();
int c = 0;
while (xml.Name == "Width")
{
if (c >= lv.Columns.Count)
return false;
lv.Columns[c++].Width = xml.ReadElementContentAsInt();
}
xml.Read();
return true;
}
public override void ReadXml(System.Xml.XmlReader reader)
{
//Template could be either an attribute containing path or expressed inlined
//as a Template Element
using (System.Xml.XmlReader subTree = reader.ReadSubtree())
{
subTree.Read();
string template = reader.GetAttribute("Template");
string tmp = subTree.ReadOuterXml();
//Load template from path set as attribute in templated control
if (string.IsNullOrEmpty(template))
{
//seek for template tag first
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
//load template first if inlined
xr.Read(); //read first child
xr.Read(); //skip root node
while (!xr.EOF)
{
if (!xr.IsStartElement())
{
xr.Read();
continue;
}
if (xr.Name == "ItemTemplate")
{
string dataType = "default", datas = "", itemTmp;
while (xr.MoveToNextAttribute())
{
if (xr.Name == "DataType")
{
dataType = xr.Value;
}
else if (xr.Name == "Data")
{
datas = xr.Value;
}
}
xr.MoveToElement();
itemTmp = xr.ReadInnerXml();
if (ItemTemplates == null)
{
ItemTemplates = new Dictionary <string, ItemTemplate> ();
}
using (IMLReader iTmp = new IMLReader(null, itemTmp)) {
ItemTemplates [dataType] =
new ItemTemplate(iTmp.RootType, iTmp.GetLoader(), dataType, datas);
}
if (!string.IsNullOrEmpty(datas))
{
ItemTemplates [dataType].CreateExpandDelegate(this);
}
continue;
}
if (xr.Name == "Template")
{
xr.Read();
Type t = Type.GetType("Crow." + xr.Name);
if (t == null)
{
Assembly a = Assembly.GetEntryAssembly();
foreach (Type expT in a.GetExportedTypes())
{
if (expT.Name == xr.Name)
{
t = expT;
}
}
}
GraphicObject go = (GraphicObject)Activator.CreateInstance(t);
(go as IXmlSerializable).ReadXml(xr);
loadTemplate(go);
continue;
}
xr.ReadInnerXml();
}
}
}
else
{
loadTemplate(CurrentInterface.Load(template));
}
//if no template found, load default one
if (this.child == null)
{
loadTemplate();
}
//normal xml read
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read();
base.ReadXml(xr);
}
}
}
