/// <summary>
/// Checks whether an attribute is an property attribute.
/// </summary>
/// <param name="attr">Attribute to Test.</param>
/// <param name="nsMapper">The namespace prefix mappings to use when expanding the namespace prefix of the attribute.</param>
/// <returns>True if is an property attribute.</returns>
public static bool IsPropertyAttribute(AttributeEvent attr, INamespaceMapper nsMapper)
{
// QName must be a valid Property Attribute Uri
// Any string value allowed so if Uri test is true then we're a property Attribute
return(nsMapper.HasNamespace(attr.Namespace) &&
IsPropertyAttributeURI(nsMapper.GetNamespaceUri(attr.Namespace), attr.LocalName));
}
/// <summary>
/// Checks whether an attribute is an rdf:datatype attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an rdf:datatype attribute</returns>
public static bool IsDataTypeAttribute(AttributeEvent attr)
{
//QName must be rdf:datatype
if (attr.QName.Equals("rdf:datatype"))
{
//Must be a valid RDF Uri Reference
return(IsRdfUriReference(attr.Value));
}
else
{
return(false);
}
}
/// <summary>
/// Checks whether an attribute is an rdf:datatype attribute.
/// </summary>
/// <param name="attr">Attribute to Test.</param>
/// <param name="namespaceMapper">The namespace prefix mappings to use when expanding the namespace prefix of the attribute.</param>
/// <returns>True if is an rdf:datatype attribute.</returns>
public static bool IsDataTypeAttribute(AttributeEvent attr, INestedNamespaceMapper namespaceMapper)
{
// QName must be rdf:datatype
if (namespaceMapper.HasNamespace(attr.Namespace) && namespaceMapper.GetNamespaceUri(attr.Namespace).ToString().Equals(NamespaceMapper.RDF) && attr.LocalName.Equals("datatype"))
{
// Must be a valid RDF Uri Reference
return(IsRdfUriReference(attr.Value));
}
else
{
return(false);
}
}
/// <summary>
/// Checks whether an attribute is an rdf:about attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an rdf:about attribute</returns>
public static bool IsAboutAttribute(AttributeEvent attr)
{
//QName must be rdf:id
if (attr.QName.Equals("rdf:about"))
{
//Must be a valid RDF Uri Reference
return(IsRdfUriReference(attr.Value));
}
else
{
return(false);
}
}
/// <summary>
/// Checks whether an attribute is an rdf:about attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an rdf:about attribute</returns>
public static bool IsAboutAttribute(AttributeEvent attr)
{
//QName must be rdf:id
if (attr.QName.Equals("rdf:about"))
{
//Must be a valid RDF Uri Reference
return IsRdfUriReference(attr.Value);
}
else
{
return false;
}
}
/// <summary>
/// Checks whether an attribute is an rdf:resource attribute.
/// </summary>
/// <param name="attr">Attribute to Test.</param>
/// <param name="nsMapper">The namespace prefix mappings to use when expanding the namespace prefix of the attribute.</param>
/// <returns>True if is an rdf:resource attribute.</returns>
public static bool IsResourceAttribute(AttributeEvent attr, INamespaceMapper nsMapper)
{
// QName must be rdf:resource
if (nsMapper.HasNamespace(attr.Namespace) &&
nsMapper.GetNamespaceUri(attr.Namespace).ToString().Equals(NamespaceMapper.RDF) &&
attr.LocalName.Equals("resource"))
{
// Must be a valid RDF Uri Reference
return(IsRdfUriReference(attr.Value));
}
else
{
return(false);
}
}
public static XamlNode Parse(string xml, NodeEvent evstart, NodeEvent evend, AttributeEvent evattr)
{
XamlNode root;
bool exists = cache.TryGetValue(xml, out root);
if (!exists)
{
root = new XamlNode()
{
outerXml = xml
}
}
;
root.Parse(evstart, evend, evattr);
if (!exists)
{
cache[xml] = root;
}
return(root);
}
/// <summary>
/// Checks whether an attribute is an rdf:nodeID attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an rdf:nodeID attribute</returns>
/// <remarks>Does some validation on ID value but other validation occurs in the <see cref="ValidateID()">ValidateID</see> method which is called at other points in the Parsing</remarks>
public static bool IsNodeIDAttribute(AttributeEvent attr)
{
//QName must be rdf:nodeID
if (attr.QName.Equals("rdf:nodeID"))
{
//Must be a valid RDF ID
if (IsRdfID(attr.Value))
{
//OK
return(true);
}
else
{
//Invalid RDF ID so Error
throw ParserHelper.Error("The value '" + attr.Value + "' for rdf:id is not valid, RDF IDs can only be valid NCNames as defined by the W3C XML Namespaces specification", attr);
}
}
else
{
return(false);
}
}
/// <summary>
/// Checks whether an attribute is an rdf:nodeID attribute.
/// </summary>
/// <param name="attr">Attribute to Test.</param>
/// <param name="nsMapper">The namespace prefix mappings to use when expanding the namespace prefix of the attribute.</param>
/// <returns>True if is an rdf:nodeID attribute.</returns>
/// <remarks>Does some validation on ID value but other validation occurs at other points in the Parsing.</remarks>
public static bool IsNodeIDAttribute(AttributeEvent attr, INamespaceMapper nsMapper)
{
// QName must be rdf:nodeID
if (nsMapper.HasNamespace(attr.Namespace) && nsMapper.GetNamespaceUri(attr.Namespace).ToString().Equals(NamespaceMapper.RDF) && attr.LocalName.Equals("nodeID"))
{
// Must be a valid RDF ID
if (IsRdfID(attr.Value))
{
// OK
return(true);
}
else
{
// Invalid RDF ID so Error
throw ParserHelper.Error("The value '" + attr.Value + "' for rdf:id is not valid, RDF IDs can only be valid NCNames as defined by the W3C XML Namespaces specification", attr);
}
}
else
{
return(false);
}
}
/**
* @node If it's not null, it probably means we're on the top node and just
* got called from public Parse method
* @parent If it's null, it means we're on the top node
* @skip don't do a read, we're already on the next node and ready to process it
*
* If this method returns null, it means it has reached the end of the current
* xml subtree (the end element of the parent node)
**/
static XamlNode Parse(XmlReader reader, XamlNode parent, XamlNode node,
NodeEvent evstart, NodeEvent evend,
AttributeEvent evattr, bool skip = false)
{
if (!skip)
{
reader.Read();
}
if (parent == null)
{
while (reader.NodeType != XmlNodeType.Element)
{
if (!reader.Read())
{
return(null);
}
}
}
else
{
do
{
while (reader.NodeType != XmlNodeType.Element &&
reader.NodeType != XmlNodeType.EndElement &&
reader.NodeType != XmlNodeType.Text)
{
if (!reader.Read())
{
return(null);
}
}
if (reader.NodeType == XmlNodeType.Element &&
parent.top.IgnorablePrefixes.Contains(reader.Prefix))
{
reader.Skip();
}
else
{
break;
}
} while (true);
}
if (reader.NodeType == XmlNodeType.EndElement)
{
return(null);
}
if (node == null)
{
node = new XamlNode();
}
node.Parsed = false;
node.Ignore = false;
if (!node.Initialized)
{
node.parent = parent;
if (parent != null)
{
node.top = parent.top;
}
else
{
node.ignorablePrefixes = new List <string> ();
node.top = node;
}
node.type = reader.NodeType;
node.namespaceURI = reader.NamespaceURI;
node.prefix = reader.Prefix;
node.name = reader.Name;
node.localName = reader.LocalName;
node.IsEmptyElement = reader.IsEmptyElement;
node.HasValue = reader.HasValue;
node.XmlSpace = reader.XmlSpace;
node.LineNumber = -1;
node.LinePosition = -1;
node.IsNsXaml = node.NamespaceURI == XamlUri;
node.IsNsClr = node.NamespaceURI.StartsWith("clr-namespace");
if (parent == null)
{
node.DefaultXmlns = reader.GetAttribute("xmlns");
}
if (node.IsNsClr)
{
int end = node.NamespaceURI.IndexOf(';');
if (end == -1)
{
end = node.NamespaceURI.Length;
}
node.ClrNamespace = node.NamespaceURI.Substring(14, end - 14);
}
if (node.IsNsClr && node.NamespaceURI.IndexOf(";assembly=") + 10 < node.NamespaceURI.Length)
{
node.Assembly = node.NamespaceURI.Substring(node.NamespaceURI.IndexOf(";assembly=") + 10);
}
if (node.HasValue)
{
node.val = reader.Value;
}
IXmlLineInfo linfo = reader as IXmlLineInfo;
if (linfo != null)
{
node.LineNumber = linfo.LineNumber;
node.LinePosition = linfo.LinePosition;
}
if (reader.HasAttributes)
{
string ig = reader.GetAttribute("Ignorable", IgnorableUri);
if (ig != null)
{
foreach (string s in ig.Split(' '))
{
node.IgnorablePrefixes.Add(s);
}
}
reader.MoveToFirstAttribute();
int count = 0;
do
{
// this filters out ignorable attributes
if (node.IgnorablePrefixes.Contains(reader.Prefix))
{
continue;
}
XamlAttribute ai = new XamlAttribute(reader)
{
Index = count++,
};
// an x: or equivalent attribute
ai.IsNsXaml = !ai.IsMapping && ai.NamespaceURI == XamlUri;
// an mc: or equivalent attribute (this attribute defines the list of ignorable prefixes)
ai.IsNsIgnorable = !ai.IsMapping && (ai.NamespaceURI == IgnorableUri || ai.Prefix == "mc");
// an xmlns:my='clr-namespace...' attribute
ai.IsNsClr = !ai.IsMapping && ai.NamespaceURI.StartsWith("clr-namespace");
if (ai.IsNsXaml && ai.LocalName == "Class")
{
node.Class = ai.Value;
}
if (ai.IsMapping)
{
if (node.top != node)
{
ai.Index = node.top.Attributes.Count;
}
node.top.Attributes [reader.Name] = ai;
}
else
{
if (ai.IsNsXaml)
{
if (ai.LocalName == "Key")
{
node.X_Key = ai.Value;
}
else if (ai.LocalName == "Name")
{
node.X_Name = ai.Value;
}
}
node.Attributes [reader.Name] = ai;
}
} while (reader.MoveToNextAttribute());
reader.MoveToElement();
}
node.Initialized = true;
}
if (evstart != null && (node.NodeType == XmlNodeType.Element || node.NodeType == XmlNodeType.Text))
{
evstart(node);
}
if (evattr != null)
{
foreach (XamlAttribute ai in node.Attributes.Values.Where(x => !x.IsNsIgnorable && !x.IsMapping))
{
evattr(node, ai);
}
}
if (node.Ignore)
{
node.outerXml = reader.ReadOuterXml();
cache [node.outerXml] = node;
if (evend != null && node.NodeType == XmlNodeType.Element)
{
evend(node);
}
return(node);
}
if (node.NodeType == XmlNodeType.Element && !node.IsEmptyElement)
{
XamlNode child = null;
do
{
child = Parse(reader, node, null, evstart, evend, evattr, child != null ? child.Ignore : false);
if (child != null)
{
child.Parsed = !child.Ignore;
node.Children.Add(child);
}
} while (child != null);
}
if (evend != null && node.NodeType == XmlNodeType.Element)
{
evend(node);
}
return(node);
}
public void Parse(NodeEvent evstart, NodeEvent evend, AttributeEvent evattr)
{
#if LOGGING
Log("Looping: Ignored? {0} Parsed? {1} {2}", this.Ignore, this.Parsed, outerXml);
#endif
Ignore = false;
if (!Initialized)
{
XmlReader reader = XmlReader.Create(new StringReader(outerXml));
Parse(reader, parent, this, evstart, evend, evattr);
Parsed = !Ignore;
return;
}
if (evstart != null && (NodeType == XmlNodeType.Element || NodeType == XmlNodeType.Text))
{
evstart(this);
}
if (evattr != null)
{
foreach (XamlAttribute ai in Attributes.Values.Where(x => !x.IsNsIgnorable && !x.IsMapping))
{
evattr(this, ai);
}
}
if (NodeType == XmlNodeType.Element && !IsEmptyElement && !Ignore)
{
if (!Parsed)
{
XmlReader reader = XmlReader.Create(new StringReader(outerXml));
reader.Read();
XamlNode child = null;
do
{
child = Parse(reader, this, null, evstart, evend, evattr, child != null ? child.Ignore : false);
if (child != null)
{
child.Parsed = !child.Ignore;
Children.Add(child);
}
} while (child != null);
Parsed = true;
}
else
{
foreach (XamlNode child in Children)
{
child.Parse(evstart, evend, evattr);
}
}
}
if (evend != null && NodeType == XmlNodeType.Element)
{
evend(this);
}
Ignore = false;
}
private static void Main(string[] args)
{
Setup();
while (true)
{
Console.WriteLine("Enter message (or quit to exit)");
Console.Write("> ");
var value = Console.ReadLine();
if ("quit".Equals(value, StringComparison.OrdinalIgnoreCase))
{
break;
}
var message = new HpImplementation {
SystemVersion = value + "-" + DateTime.Now
};
if ("send".Equals(value, StringComparison.OrdinalIgnoreCase))
{
_bus.Send("MassTransit.Tests.Consumer", message);
}
else if ("rr" == value)
{
using (var scope = ObjectContainer.BeginLifetimeScope())
{
var client = scope.Resolve <ESS.FW.Common.ServiceBus.IRequestClient <Request, RequestResult> >();
Task.Run(() =>
{
var result =
client.Request("MassTransit.Tests.Consumer",
new Request {
Message = "request"
}, new CancellationToken()).Result;
Console.WriteLine(result.Message);
});
}
}
//else if ("trans" == value)
// _bus.Publish(new TransactionEvent { Message = "transaction test" });
else if ("order" == value)
{
for (var i = 0; i < 100; i++)
{
_bus.Send("MassTransit.Tests.Consumer",
new HpImplementation {
SystemVersion = i + "-" + DateTime.Now
}, true);
}
}
//else if ("orderp" == value)
// for (var i = 0; i < 100; i++)
// _bus.OrderPublish(
// new HpImplementation { SystemVersion = i + "-" + DateTime.Now });
else if ("attr" == value)
{
var msg = new AttributeEvent();
msg.Message = DateTime.Now.ToString();
_bus.Send("AttributeEvent", msg, true);
}
else
{
_bus.Send("MassTransit.Tests.Consumer", message, true);
}
}
Console.ReadKey();
}
/// <summary>
/// Checks whether an attribute is an property attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an property attribute</returns>
public static bool IsPropertyAttribute(AttributeEvent attr)
{
//QName must be a valid Property Attribute Uri
//Any string value allowed so if Uri test is true then we're a property Attribute
return IsPropertyAttributeURI(attr.QName);
}
/// <summary>
/// Checks whether an attribute is an rdf:parseType attribute.
/// </summary>
/// <param name="attr">Attribute to Test.</param>
/// <param name="nsMapper">The namespace prefix mappings to use when expanding the namespace prefix of the attribute.</param>
/// <returns>True if is an rdf:parseType attribute.</returns>
public static bool IsParseTypeAttribute(AttributeEvent attr, INestedNamespaceMapper nsMapper)
{
return(nsMapper.HasNamespace(attr.Namespace) &&
nsMapper.GetNamespaceUri(attr.Namespace).ToString().Equals(NamespaceMapper.RDF) &&
attr.LocalName.Equals("parseType"));
}
/// <summary>
/// Checks whether an attribute is an rdf:type attribute.
/// </summary>
/// <param name="attr">The attribute to check.</param>
/// <param name="nsMapper">The namespace prefix mappings to use to expand QNames.</param>
/// <returns>True if the attribute is and rdf:type attribute, false otherwise.</returns>
public static bool IsTypeAttribute(AttributeEvent attr, INamespaceMapper nsMapper)
{
return(nsMapper.HasNamespace(attr.Namespace) &&
IsRdfNamespace(nsMapper.GetNamespaceUri(attr.Namespace)) &&
attr.LocalName.Equals("type"));
}
/// <summary>
/// Checks whether an attribute is an property attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an property attribute</returns>
public static bool IsPropertyAttribute(AttributeEvent attr)
{
//QName must be a valid Property Attribute Uri
//Any string value allowed so if Uri test is true then we're a property Attribute
return(IsPropertyAttributeURI(attr.QName));
}
public static XamlNode Parse (string xml, NodeEvent evstart, NodeEvent evend, AttributeEvent evattr)
{
XamlNode root;
bool exists = cache.TryGetValue (xml, out root);
if (!exists)
root = new XamlNode () { outerXml = xml };
root.Parse (evstart, evend, evattr);
if (!exists)
cache[xml] = root;
return root;
}
/// <summary>
/// Checks whether an attribute is an rdf:nodeID attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an rdf:nodeID attribute</returns>
/// <remarks>Does some validation on ID value but other validation occurs in the <see cref="ValidateID()">ValidateID</see> method which is called at other points in the Parsing</remarks>
public static bool IsNodeIDAttribute(AttributeEvent attr)
{
//QName must be rdf:nodeID
if (attr.QName.Equals("rdf:nodeID"))
{
//Must be a valid RDF ID
if (IsRdfID(attr.Value))
{
//OK
return true;
}
else
{
//Invalid RDF ID so Error
throw ParserHelper.Error("The value '" + attr.Value + "' for rdf:id is not valid, RDF IDs can only be valid NCNames as defined by the W3C XML Namespaces specification", attr);
}
}
else
{
return false;
}
}
public void Parse (NodeEvent evstart, NodeEvent evend, AttributeEvent evattr)
{
#if LOGGING
Log ("Looping: Ignored? {0} Parsed? {1} {2}", this.Ignore, this.Parsed, outerXml);
#endif
Ignore = false;
if (!Initialized) {
XmlReader reader = XmlReader.Create (new StringReader (outerXml));
Parse (reader, parent, this, evstart, evend, evattr);
Parsed = !Ignore;
return;
}
if (evstart != null && (NodeType == XmlNodeType.Element || NodeType == XmlNodeType.Text))
evstart (this);
if (evattr != null) {
foreach (XamlAttribute ai in Attributes.Values.Where (x => !x.IsNsIgnorable && !x.IsMapping))
evattr (this, ai);
}
if (NodeType == XmlNodeType.Element && !IsEmptyElement && !Ignore) {
if (!Parsed) {
XmlReader reader = XmlReader.Create (new StringReader (outerXml));
reader.Read ();
XamlNode child = null;
do {
child = Parse (reader, this, null, evstart, evend, evattr, child != null ? child.Ignore : false);
if (child != null) {
child.Parsed = !child.Ignore;
Children.Add (child);
}
} while (child != null);
Parsed = true;
} else {
foreach (XamlNode child in Children) {
child.Parse (evstart, evend, evattr);
}
}
}
if (evend != null && NodeType == XmlNodeType.Element)
evend (this);
Ignore = false;
}
/// <summary>
/// Checks whether an attribute is an rdf:datatype attribute
/// </summary>
/// <param name="attr">Attribute to Test</param>
/// <returns>True if is an rdf:datatype attribute</returns>
public static bool IsDataTypeAttribute(AttributeEvent attr)
{
//QName must be rdf:datatype
if (attr.QName.Equals("rdf:datatype"))
{
//Must be a valid RDF Uri Reference
return IsRdfUriReference(attr.Value);
}
else
{
return false;
}
}
/**
@node If it's not null, it probably means we're on the top node and just
got called from public Parse method
@parent If it's null, it means we're on the top node
@skip don't do a read, we're already on the next node and ready to process it
If this method returns null, it means it has reached the end of the current
xml subtree (the end element of the parent node)
**/
static XamlNode Parse (XmlReader reader, XamlNode parent, XamlNode node,
NodeEvent evstart, NodeEvent evend,
AttributeEvent evattr, bool skip = false)
{
if (!skip)
reader.Read ();
if (parent == null) {
while (reader.NodeType != XmlNodeType.Element)
if (!reader.Read ())
return null;
} else {
do {
while (reader.NodeType != XmlNodeType.Element &&
reader.NodeType != XmlNodeType.EndElement &&
reader.NodeType != XmlNodeType.Text) {
if (!reader.Read ())
return null;
}
if (reader.NodeType == XmlNodeType.Element &&
parent.top.IgnorablePrefixes.Contains (reader.Prefix))
reader.Skip ();
else
break;
} while (true);
}
if (reader.NodeType == XmlNodeType.EndElement)
return null;
if (node == null)
node = new XamlNode ();
node.Parsed = false;
node.Ignore = false;
if (!node.Initialized) {
node.parent = parent;
if (parent != null)
node.top = parent.top;
else {
node.ignorablePrefixes = new List<string> ();
node.top = node;
}
node.type = reader.NodeType;
node.namespaceURI = reader.NamespaceURI;
node.prefix = reader.Prefix;
node.name = reader.Name;
node.localName = reader.LocalName;
node.IsEmptyElement = reader.IsEmptyElement;
node.HasValue = reader.HasValue;
node.XmlSpace = reader.XmlSpace;
node.LineNumber = -1;
node.LinePosition = -1;
node.IsNsXaml = node.NamespaceURI == XamlUri;
node.IsNsClr = node.NamespaceURI.StartsWith ("clr-namespace");
if (parent == null)
node.DefaultXmlns = reader.GetAttribute ("xmlns");
if (node.IsNsClr) {
int end = node.NamespaceURI.IndexOf (';');
if (end == -1)
end = node.NamespaceURI.Length;
node.ClrNamespace = node.NamespaceURI.Substring (14, end - 14);
}
if (node.IsNsClr && node.NamespaceURI.IndexOf (";assembly=") + 10 < node.NamespaceURI.Length)
node.Assembly = node.NamespaceURI.Substring (node.NamespaceURI.IndexOf (";assembly=") + 10);
if (node.HasValue)
node.val = reader.Value;
IXmlLineInfo linfo = reader as IXmlLineInfo;
if (linfo != null) {
node.LineNumber = linfo.LineNumber;
node.LinePosition = linfo.LinePosition;
}
if (reader.HasAttributes) {
string ig = reader.GetAttribute ("Ignorable", IgnorableUri);
if (ig != null) {
foreach (string s in ig.Split (' '))
node.IgnorablePrefixes.Add (s);
}
reader.MoveToFirstAttribute ();
int count = 0;
do {
// this filters out ignorable attributes
if (node.IgnorablePrefixes.Contains (reader.Prefix))
continue;
XamlAttribute ai = new XamlAttribute (reader) {
Index = count++,
};
// an x: or equivalent attribute
ai.IsNsXaml = !ai.IsMapping && ai.NamespaceURI == XamlUri;
// an mc: or equivalent attribute (this attribute defines the list of ignorable prefixes)
ai.IsNsIgnorable = !ai.IsMapping && (ai.NamespaceURI == IgnorableUri || ai.Prefix == "mc");
// an xmlns:my='clr-namespace...' attribute
ai.IsNsClr = !ai.IsMapping && ai.NamespaceURI.StartsWith ("clr-namespace");
if (ai.IsNsXaml && ai.LocalName == "Class")
node.Class = ai.Value;
if (ai.IsMapping) {
if (node.top != node)
ai.Index = node.top.Attributes.Count;
node.top.Attributes [reader.Name] = ai;
} else {
if (ai.IsNsXaml) {
if (ai.LocalName == "Key")
node.X_Key = ai.Value;
else if (ai.LocalName == "Name")
node.X_Name = ai.Value;
}
node.Attributes [reader.Name] = ai;
}
} while (reader.MoveToNextAttribute ());
reader.MoveToElement ();
}
node.Initialized = true;
}
if (evstart != null && (node.NodeType == XmlNodeType.Element || node.NodeType == XmlNodeType.Text))
evstart (node);
if (evattr != null) {
foreach (XamlAttribute ai in node.Attributes.Values.Where (x => !x.IsNsIgnorable && !x.IsMapping))
evattr (node, ai);
}
if (node.Ignore) {
node.outerXml = reader.ReadOuterXml ();
cache [node.outerXml] = node;
if (evend != null && node.NodeType == XmlNodeType.Element)
evend (node);
return node;
}
if (node.NodeType == XmlNodeType.Element && !node.IsEmptyElement) {
XamlNode child = null;
do {
child = Parse (reader, node, null, evstart, evend, evattr, child != null ? child.Ignore : false);
if (child != null) {
child.Parsed = !child.Ignore;
node.Children.Add (child);
}
} while (child != null);
}
if (evend != null && node.NodeType == XmlNodeType.Element)
evend (node);
return node;
}
