internal int AppendAttributeValue(XmlTextReader reader)
{
int num = 0;
char quoteChar = reader.QuoteChar;
if ((quoteChar != '"') && (quoteChar != '\''))
{
quoteChar = '"';
}
num += this.Write(quoteChar);
while (reader.ReadAttributeValue())
{
if (reader.NodeType == XmlNodeType.Text)
{
num += this.AppendEscapeXmlString(reader.Value, true, quoteChar);
}
else
{
num += this.AppendEntityRef(reader.Name);
}
}
return (num + this.Write(quoteChar));
}
internal int AppendAttributeValue(XmlTextReader reader)
{
int charactersWritten = 0;
char quote = reader.QuoteChar;
// In !DOCTYPE, quote is '\0' for second public attribute.
// Protect ourselves from writing invalid XML by always
// supplying a valid quote char.
if ((quote != '"') && (quote != '\'')) quote = '"';
charactersWritten += Write(quote);
while (reader.ReadAttributeValue())
if (reader.NodeType == XmlNodeType.Text)
charactersWritten += AppendEscapeXmlString(reader.Value, true, quote);
else charactersWritten += AppendEntityRef(reader.Name);
charactersWritten += Write(quote);
return charactersWritten;
}
public void PreserveEntity ()
{
string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";
string dtd = "<!DOCTYPE root [" + intSubset + "]>";
string xml = dtd + "<root foo='&ent;' bar='internal &ent; value' />";
XmlTextReader dvr = new XmlTextReader (xml, XmlNodeType.Document, null);
dvr.EntityHandling = EntityHandling.ExpandCharEntities;
dvr.Read (); // DTD
dvr.Read ();
AssertEquals (XmlNodeType.Element, dvr.NodeType);
AssertEquals ("root", dvr.Name);
Assert (dvr.MoveToFirstAttribute ());
AssertEquals ("foo", dvr.Name);
// MS BUG: it returns "entity string", however, entity should not be exanded.
AssertEquals ("&ent;", dvr.Value);
// ReadAttributeValue()
Assert (dvr.ReadAttributeValue ());
AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
AssertEquals ("ent", dvr.Name);
AssertEquals ("", dvr.Value);
Assert (!dvr.ReadAttributeValue ());
// bar
Assert (dvr.MoveToNextAttribute ());
AssertEquals ("bar", dvr.Name);
AssertEquals ("internal &ent; value", dvr.Value);
// ReadAttributeValue()
Assert (dvr.ReadAttributeValue ());
AssertEquals (XmlNodeType.Text, dvr.NodeType);
AssertEquals ("", dvr.Name);
AssertEquals ("internal ", dvr.Value);
Assert (dvr.ReadAttributeValue ());
AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);
AssertEquals ("ent", dvr.Name);
AssertEquals ("", dvr.Value);
Assert (dvr.ReadAttributeValue ());
AssertEquals (XmlNodeType.Text, dvr.NodeType);
AssertEquals ("", dvr.Name);
AssertEquals (" value", dvr.Value);
}
public void AttributeWithEntityReference ()
{
string xml = @"<a value='hello &ent; world' />";
XmlReader xmlReader =
new XmlTextReader (new StringReader (xml));
xmlReader.Read ();
xmlReader.MoveToFirstAttribute ();
xmlReader.ReadAttributeValue ();
AssertEquals ("hello ", xmlReader.Value);
Assert (xmlReader.ReadAttributeValue ());
AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
AssertEquals ("ent", xmlReader.Name);
AssertEquals (XmlNodeType.EntityReference, xmlReader.NodeType);
Assert (xmlReader.ReadAttributeValue ());
AssertEquals (" world", xmlReader.Value);
AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
Assert (!xmlReader.ReadAttributeValue ());
AssertEquals (" world", xmlReader.Value); // remains
AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
xmlReader.ReadAttributeValue ();
AssertEquals (XmlNodeType.Text, xmlReader.NodeType);
}
public void ReadFromXML(string sFileName)
{
m_AnimFrameInfoList.Clear();
m_AnimFrameInfoList = new List <AnimatedFrameInfo>();
int iTotalFrames = 0;
int iPartialCompletionFrame = 0;
int iCurrentFrameElement = 1;
System.Xml.XmlTextReader XmlReader = new System.Xml.XmlTextReader(sFileName);
System.Xml.XmlNodeType XmlType;
while (XmlReader.Read())
{
XmlReader.ReadAttributeValue();
XmlType = XmlReader.NodeType;
if (XmlType == System.Xml.XmlNodeType.Element)
{
//===========================================
// Get Main Info
//===========================================
if (XmlReader.Name == "AnimationInfo")
{
iTotalFrames = Convert.ToInt32(XmlReader.GetAttribute("TotalFrames"));
iPartialCompletionFrame = Convert.ToInt32(XmlReader.GetAttribute("PartialAnimationCompletionFrame"));
m_bRelativeToScreen = XmlReader.GetAttribute("RelativeToScreen") == "1";
}
//===========================================
// Get Frame Info
//===========================================
if (XmlReader.Name == "Frame" + iCurrentFrameElement.ToString())
{
AnimatedFrameInfo AFI = new AnimatedFrameInfo();
AFI.m_bTintScreen = XmlReader.GetAttribute("TintScreen") == "1";
AFI.m_iTintScreenRed = Convert.ToInt32(XmlReader.GetAttribute("ScreenTintRed"));
AFI.m_iTintScreenGreen = Convert.ToInt32(XmlReader.GetAttribute("ScreenTintGreen"));
AFI.m_iTintScreenBlue = Convert.ToInt32(XmlReader.GetAttribute("ScreenTintBlue"));
AFI.m_iTintScreenAlpha = Convert.ToInt32(XmlReader.GetAttribute("ScreenTintAlpha"));
AFI.m_bTintCharacter = XmlReader.GetAttribute("TintCharacter") == "1";
AFI.m_iTintCharacterRed = Convert.ToInt32(XmlReader.GetAttribute("CharacterTintRed"));
AFI.m_iTintCharacterGreen = Convert.ToInt32(XmlReader.GetAttribute("CharacterTintGreen"));
AFI.m_iTintCharacterBlue = Convert.ToInt32(XmlReader.GetAttribute("CharacterTintBlue"));
AFI.m_iWaitTimeTillNextFrame = Convert.ToInt32(XmlReader.GetAttribute("WaitTillNextFrame"));
AFI.m_sSoundFilename = XmlReader.GetAttribute("SoundFilename");
int iTotalSprites = Convert.ToInt32(XmlReader.GetAttribute("TotalSprites"));
for (int i = 0; i < iTotalSprites;)
{
XmlReader.Read();
if (XmlReader.Name == "Sprite" + (i + 1).ToString())
{
SpriteInfo SprInfo = new SpriteInfo();
SprInfo.ID = (uint)AFI.m_SpriteInfoList.Count;
SprInfo.TextureName = XmlReader.GetAttribute("TextureName");
SprInfo.X = Convert.ToInt32(XmlReader.GetAttribute("X"));
SprInfo.Y = Convert.ToInt32(XmlReader.GetAttribute("Y"));
SprInfo.W = Convert.ToInt32(XmlReader.GetAttribute("W"));
SprInfo.H = Convert.ToInt32(XmlReader.GetAttribute("H"));
// Multiplying By 1000 Because the Game uses a float value of 0-1, whereas this program uses whole pixels.
// Therefore it is saved in game format, but when being read back into this program, the float is multiplied
// by 1000 to give an integer pass value, which is corrected by a SpriteChecker function outside of this class.
int RectX = (int)(Convert.ToDouble(XmlReader.GetAttribute("UVCoordStartX")) * 1000.0);
int RectY = (int)(Convert.ToDouble(XmlReader.GetAttribute("UVCoordStartY")) * 1000.0);
int RectW = (int)(Convert.ToDouble(XmlReader.GetAttribute("UVCoordEndX")) * 1000.0);
int RectH = (int)(Convert.ToDouble(XmlReader.GetAttribute("UVCoordEndY")) * 1000.0);
SprInfo.BlitRect = new Rectangle(RectX, RectY, RectW, RectH);
AFI.m_SpriteInfoList.Add(SprInfo);
i++;
}
}
m_AnimFrameInfoList.Add(AFI);
iCurrentFrameElement++;
}
}
}
//===========================================
// Finish Up
//===========================================
if ((iPartialCompletionFrame + 1) < m_AnimFrameInfoList.Count)
{
m_AnimFrameInfoList.ElementAt(iPartialCompletionFrame - 1).m_bAnimationPartiallyCompleted = true;
}
XmlReader.Close();
}
public void XmlDeclarationReadAttributeValue2 ()
{
const string input = "<?xml version=\"1.0\" encoding=\"utf-8\"?><hello />";
var reader = new XmlTextReader (new StringReader (input));
reader.WhitespaceHandling = WhitespaceHandling.All;
reader.Read ();
Assert.IsTrue (reader.MoveToNextAttribute (), "#1a");
Assert.IsTrue (reader.ReadAttributeValue (), "#1b");
Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#1c");
Assert.AreEqual ("1.0", reader.Value, "#1d");
Assert.IsFalse (reader.ReadAttributeValue(), "#1e");
Assert.IsTrue (reader.MoveToNextAttribute(), "#2a");
Assert.IsTrue (reader.ReadAttributeValue(), "#2b");
Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#2c");
Assert.AreEqual ("utf-8", reader.Value, "#2d");
Assert.IsFalse (reader.ReadAttributeValue(), "#2e");
Assert.IsFalse (reader.MoveToNextAttribute(), "#3");
Assert.IsFalse (reader.ReadAttributeValue(), "#4");
Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#5");
}
public void XmlDeclarationReadAttributeValue ()
{
const string input = "<?xml version=\"1.0\" encoding=\"utf-8\"?><hello />";
var reader = new XmlTextReader (new StringReader (input));
reader.WhitespaceHandling = WhitespaceHandling.All;
reader.Read ();
Assert.AreEqual ("1.0", reader.GetAttribute ("version"), "#0");
Assert.AreEqual ("utf-8", reader.GetAttribute ("encoding"), "#0-2");
Assert.IsTrue (reader.MoveToNextAttribute (), "#1");
Assert.AreEqual ("1.0", reader.Value, "#1-1");
Assert.IsTrue (reader.ReadAttributeValue (), "#2");
Assert.AreEqual ("1.0", reader.Value, "#3");
Assert.IsFalse (reader.ReadAttributeValue (), "#4");
Assert.IsTrue (reader.MoveToNextAttribute (), "#5");
Assert.AreEqual ("utf-8", reader.Value, "#5-1");
Assert.IsTrue (reader.ReadAttributeValue (), "#6");
Assert.AreEqual ("utf-8", reader.Value, "#7");
Assert.IsFalse (reader.ReadAttributeValue (), "#8");
Assert.IsFalse (reader.MoveToNextAttribute (), "#9");
Assert.IsFalse (reader.ReadAttributeValue (), "#10");
}
public override void Read (XmlTextReader xml, bool start)
{
if (CanSerialize) {
base.Read (xml, start);
if (start) {
while (xml.MoveToNextAttribute()) {
string name = xml.Name;
xml.ReadAttributeValue();
Attributes [name] = xml.Value;
OnAttributeRead (name);
Logger.Debug (
"NoteTag: {0} read attribute {1}='{2}'",
ElementName,
name,
xml.Value);
}
}
}
}
public void ReadFromXML(string sFileName)
{
m_lLevelInfoList = new List <List <LevelInfo> >();
System.Xml.XmlTextReader XmlReader = new System.Xml.XmlTextReader(sFileName);
System.Xml.XmlNodeType XmlType;
while (XmlReader.Read())
{
XmlReader.ReadAttributeValue();
XmlType = XmlReader.NodeType;
if (XmlType == System.Xml.XmlNodeType.Element)
{
//===========================================
// Get LevelSize Info
//===========================================
if (XmlReader.Name == "LevelSize")
{
m_sTileRows = XmlReader.GetAttribute("Rows");
m_sTileCols = XmlReader.GetAttribute("Cols");
}
//===========================================
// Get Array Info
//===========================================
else if (XmlReader.Name == "Row")
{
int ColAmount = Convert.ToInt32(m_sTileCols);
List <LevelInfo> LevInfoList = new List <LevelInfo>();
for (int i = 0; i < ColAmount; i++)
{
LevelInfo LevInfo = new LevelInfo(); int CurrentCol = i + 1;
LevInfo.X = (uint)i * 32; LevInfo.Y = (uint)m_lLevelInfoList.Count() * 32; LevInfo.W = 32; LevInfo.H = 32;
LevInfo.TextureName = XmlReader.GetAttribute("Col" + CurrentCol.ToString());
LevInfoList.Add(LevInfo);
}
m_lLevelInfoList.Add(LevInfoList);
}
//===========================================
// Get Background Image Info
//===========================================
else if (XmlReader.Name == "BackgroundImage")
{
m_sBackgroundImageName = XmlReader.GetAttribute("Name");
m_sFullPathToBackgroundImage = XmlReader.GetAttribute("FullPath");
}
//===========================================
// Get Audio Info
//===========================================
else if (XmlReader.Name == "AudioName")
{
m_sAudioName = XmlReader.GetAttribute("Name");
m_sAudioLoopStart = XmlReader.GetAttribute("LoopStart");
m_sAudioLoopEnd = XmlReader.GetAttribute("LoopEnd");
}
//===========================================
// Get Weather Info
//===========================================
else if (XmlReader.Name == "EffectOne")
{
m_sWeatherEffectOne = XmlReader.GetAttribute("Type");
m_sPowerOfWeatherEffectOne = XmlReader.GetAttribute("Power");
}
else if (XmlReader.Name == "EffectTwo")
{
m_sWeatherEffectTwo = XmlReader.GetAttribute("Type");
m_sPowerOfWeatherEffectTwo = XmlReader.GetAttribute("Power");
}
}
}
//===========================================
// Finish Up
//===========================================
XmlReader.Close();
}
protected void Recurse(XmlTextReader reader, Menu root)
{
String inner = reader.ReadInnerXml();
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
XmlParserContext ctxt = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
XmlTextReader reader2 = new XmlTextReader(inner, XmlNodeType.Element, ctxt);
while (reader2.Read())
{
if (reader2.NodeType == XmlNodeType.Element)
{
switch (reader2.LocalName)
{
case "menu":
// Menuitem. Find the name, accesskey, command and id strings
String[] values = new String[3] {"", "", ""};
String[] names = new String[3] {"label", "accesskey", "command"};
for (int i = 0; i < names.Length; ++i)
{
if (reader2.MoveToAttribute(names[i]) &&
reader2.ReadAttributeValue())
values[i] = reader2.Value; // XXX need to handle entities
reader2.MoveToElement();
}
// Handle Accesskey
values[0] = ManticoreMenuItem.GenerateAccessKeyString(values[0], values[1]);
// Create menu item and attach an event handler
// BLUESKY - should we support data stored in the XML file as an attribute?
mCurrentMenuItem = new ManticoreMenuItem(values[0],
new EventHandler(OnCommandInternal),
values[2], "");
if (values[2] != "")
mItems.Add(values[2], mCurrentMenuItem);
root.MenuItems.Add(mCurrentMenuItem);
Recurse(reader2, mCurrentMenuItem);
break;
case "menuseparator":
mCurrentMenuItem = new MenuItem("-");
root.MenuItems.Add(mCurrentMenuItem);
break;
case "menubuilder":
String id = "";
if (reader2.MoveToAttribute("id") &&
reader2.ReadAttributeValue())
id = reader2.Value;
reader2.MoveToElement();
String datastore = "";
if (reader2.MoveToAttribute("datastore") &&
reader2.ReadAttributeValue())
datastore = reader2.Value;
BaseMenuBuilder builder = new BaseMenuBuilder(mMainMenu, root as MenuItem, mCurrentMenuItem, null);
builder.Root = id;
builder.DataStore = DataStoreRegistry.GetDataStore(datastore);
builder.DataStore.AddObserver(builder);
builder.OnCommand += new EventHandler(OnCommandInternal);
mBuilders.Add(builder.GetHashCode(), builder);
break;
}
}
}
}
/// <summary>
/// Fill the list with source
/// </summary>
/// <param name="XmlSourceFile"></param>
public void FillList(string XmlSourceFile)
{
XmlTextReader XmlReader=new XmlTextReader(XmlSourceFile);
while (XmlReader.Read())
{
if(XmlReader.HasAttributes & XmlReader.NodeType==System.Xml.XmlNodeType.Element)
{
if(XmlReader[0].ToUpper() != "ISO")
{
this._SourceList.Add(XmlReader[1]);
}
}
XmlReader.ReadAttributeValue();
}
}
// Read the next attribute value in the input stream.
public override bool ReadAttributeValue()
{
return(reader.ReadAttributeValue());
}
public void Build(Object sender, EventArgs e)
{
XmlTextReader reader;
reader = new XmlTextReader(mToolbarFile);
reader.WhitespaceHandling = WhitespaceHandling.None;
reader.MoveToContent();
bool shouldBuildNewRow = true;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.LocalName)
{
case "toolstrip":
// The next <toolbar/> we encounter should be created on a new row.
shouldBuildNewRow = true;
break;
case "toolbar":
String[] tbvalues = new String[4] {"", "", "", ""};
String[] tbnames = new String[4] {"id", "label", "description", "visible"};
for (int i = 0; i < tbnames.Length; ++i)
{
if (reader.MoveToAttribute(tbnames[i]) &&
reader.ReadAttributeValue())
tbvalues[i] = reader.Value; // XXX need to handle entities
reader.MoveToElement();
}
String key = tbvalues[0];
String label = tbvalues[1];
bool visible = tbvalues[3] == "true";
// Create and add a new toolbar.
mToolBar.Appearance = ToolBarAppearance.Flat;
mToolBar.ButtonClick += new ToolBarButtonClickEventHandler(this.OnCommand);
mForm.Controls.Add(mToolBar);
//mCoolBar.Bands.Add(-1, key, label, new Object(), true, mToolBar, true);
shouldBuildNewRow = false;
break;
case "toolbarseparator":
{
if (mToolBar != null)
{
ToolBarButton button = new ToolBarButton();
button.Style = ToolBarButtonStyle.Separator;
mToolBar.Buttons.Add(button);
}
break;
}
case "toolbarbutton":
{
if (mToolBar != null)
{
String[] tbbvalues = new String[3] {"", "", ""};
String[] tbbnames = new String[3] {"label", "icon", "command"};
for (int i = 0; i < tbbnames.Length; ++i)
{
if (reader.MoveToAttribute(tbbnames[i]) &&
reader.ReadAttributeValue())
tbbvalues[i] = reader.Value; // XXX need to handle entities
reader.MoveToElement();
}
ToolBarButton button = new CommandButtonItem(tbbvalues[1]);
button.Text = tbbvalues[0];
mToolBar.Buttons.Add(button);
}
break;
}
}
}
}
}
private void CatListRecurse(XmlTextReader aReader, Object aRootNode)
{
String inner = aReader.ReadInnerXml();
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
XmlParserContext ctxt = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
XmlTextReader reader2 = new XmlTextReader(inner, XmlNodeType.Element, ctxt);
TreeNode node;
while (reader2.Read()) {
if (reader2.NodeType == XmlNodeType.Element) {
switch (reader2.LocalName) {
case "panel":
// Tree node with children. Retrieve label and id. Label is
// used for visual presentation, id is hashed against node
// and is used as a key when looking for which panel to
// load.
String[] values = new String[2] {"", ""};
String[] names = new String[2] {"label", "id"};
for (int i = 0; i < names.Length; ++i) {
if (reader2.MoveToAttribute(names[i]) &&
reader2.ReadAttributeValue())
values[i] = reader2.Value;
reader2.MoveToElement();
}
node = new TreeNode(values[0], 0, 0);
if (aRootNode is TreeView) {
TreeView rootView = aRootNode as TreeView;
rootView.Nodes.Add(node);
}
else if (aRootNode is TreeNode) {
TreeNode rootNode = aRootNode as TreeNode;
rootNode.Nodes.Add(node);
}
mNodes.Add(node.GetHashCode(), values[1]);
CatListRecurse(reader2, node);
break;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
/// <param name="t"></param>
/// <returns></returns>
public object DeserializeGraph(XmlTextReader r, Type t)
{
object o = t.Assembly.CreateInstance(t.FullName);
string InstanceName = r.Name;
int i = 0;
if(o.GetType().BaseType == typeof(System.Collections.CollectionBase))
{
o = DeserializeCollection(r, t);
}
PropertyInfo[] properties = o.GetType().GetProperties(BindingFlags.Public|BindingFlags.Instance);
#region Handle XmlRoot attributes
if(r.HasAttributes)
{
while(r.MoveToNextAttribute() && i < properties.Length)
{
object[] butes = properties[i].GetCustomAttributes(false);
object bute = null;
if(butes.Length > 0)
bute = butes[0];
PropertyInfo property = null;
if(r.Name == (bute as XmlAttributeAttribute).AttributeName)
{
property = properties[i];
}
else
{
property = t.GetProperty(r.Name);
}
if(property.PropertyType.Name == "String")
{
// We have a string
r.ReadAttributeValue();
string s = r.Value;
if(property.CanWrite)
property.SetValue(o, s, null);
}
i++;
}
}
#endregion
while(r.Read() && i < properties.Length)
{
if((r.Name == InstanceName) && (r.NodeType == XmlNodeType.EndElement))
{
break;
}
object[] attribs = properties[i].GetCustomAttributes(false);
object attrib = null;
if(attribs.Length > 0)
attrib = attribs[0];
if(r.HasAttributes)
{
r.MoveToFirstAttribute();
while(r.HasAttributes)
{
PropertyInfo property = null;
if(r.Name == (attrib as XmlAttributeAttribute).AttributeName)
{
property = properties[i];
}
else
{
property = t.GetProperty(r.Name);
}
if(property.PropertyType.Name == "String")
{
// We have a string
r.ReadAttributeValue();
string s = r.Value;
if(property.CanWrite)
property.SetValue(o, s, null);
}
i++;
}
}
else if((r.NodeType == XmlNodeType.Element))
{
if(r.IsEmptyElement)
{
i++;
continue;
}
PropertyInfo property = null;
if(attrib == null)
{
property = t.GetProperty(r.Name);
if(property == null)
continue;
}
else
{
if(attrib.GetType() == typeof(XmlElementAttribute))
{
if(r.Name == (attrib as XmlElementAttribute).ElementName)
{
property = properties[i]; i++;
}
else
continue;
}
else if(attrib.GetType() == typeof(XmlAttributeAttribute))
{
if(r.Name == (attrib as XmlAttributeAttribute).AttributeName)
{
property = properties[i]; i++;
}
else
continue;
}
else if(attrib.GetType() == typeof(XmlRootAttribute))
{
if(r.Name == (attrib as XmlRootAttribute).ElementName)
{
property = properties[i]; i++;
}
else
continue;
}
}
if(property.PropertyType.BaseType == typeof(System.Collections.CollectionBase))
{
// We have a collection
property.SetValue(o, DeserializeCollection(r, property.PropertyType),null);
}
else if(property.PropertyType.Name == "String")
{
// We have a string
r.Read();
string s = r.Value;
if(property.CanWrite)
property.SetValue(o, s, null);
}
else if(property.PropertyType.IsValueType)
{
// We have a value type
object oVal = null;
if ( typeof(IConvertible).IsAssignableFrom(property.PropertyType) )
{
r.Read();
string s = r.Value;
if ( property.PropertyType.IsEnum )
{
try
{
oVal = Enum.ToObject(property.PropertyType, Convert.ToInt32(s));
}
catch(InvalidCastException)
{
}
}
else
{
try { oVal = Convert.ChangeType(s, property.PropertyType, null); }
catch(InvalidCastException)
{
try { oVal = Convert.ChangeType(s, property.PropertyType.BaseType, null); }
catch(InvalidCastException) { continue; }
}
}
}
else if ( !property.PropertyType.IsPrimitive )
{
oVal = DeserializeGraph(r, property.PropertyType);
}
if ( oVal != null )
property.SetValue(o, oVal, null);
}
else if(t.Assembly.GetType(property.PropertyType.FullName, false) != null)
{
// We have a type in the current assembly. Recurse.
object val = DeserializeGraph(r, property.PropertyType);
property.SetValue(o,val, null);
}
else
{
throw new NotSupportedException("Cannot deserialize to " + property.PropertyType.FullName + ".");
}
}
else if(r.NodeType == XmlNodeType.Text)
{
PropertyInfo property = properties[i];
i++;
if(property.PropertyType.Name == "String")
{
// We have a string
//r.Read();
string s = r.Value;
if(property.CanWrite)
property.SetValue(o, s, null);
}
}
}
return o;
}
