By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
443,706 Members | 2,030 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 443,706 IT Pros & Developers. It's quick & easy.

Easiest way to generate XML in VB.NET

P: n/a
Quick (hopefully easy) question for you guys.
What is going to be the quickest/easiest way to generate XML from VB.NET?
Note: I don't mean an XML file, but XML in memory somehow (an XML-related
object, but one that would have a method for getting the fully-formed XML
back out again).
For example, what will be my easiest way to build the following in memory:

<CommandXML>
<cmd name="1" action="2">
<arg name="3" value = "4"/>
<arg name="5" value = "6"/>
</cmd>
<cmd name="7" action="9">
<arg name="9" value = "0"/>
</cmd>
</CommandXML>

Basically, the reason I need this in memory, is I need to build this XML,
then send it (as a string) to a server component.
Thanks!
-Scott
Nov 12 '05 #1
Share this Question
Share on Google+
7 Replies


P: n/a
You'll be delightfully surprised how easy it is. You basically use the
XMLserialization object to create an object or series of nested objects
that can read in or write out XML to a text file or other output
source.

The WROX Visual Basic for Beginners book cover this in detail.

Nov 12 '05 #2

P: n/a
Scott,
As Bingomanatee suggests XML Serialization is one of the easier ways,
especially if you can represent your data as Objects. The trick is getting
the "arrays" correct (the list of commands & the list of arguments).

Something like (note the sample only supports a single cmd & a single arg):

Imports System.Xml.Serialization

Dim writer As New System.Xml.XmlTextWriter("CommandXml.xml",
System.Text.Encoding.UTF8)
writer.Formatting = Xml.Formatting.Indented
writer.Indentation = 1
writer.IndentChar = ControlChars.Tab

Dim serializer As New
System.Xml.Serialization.XmlSerializer(GetType(Com mandXml))

Dim command As New CommandXml
command.Command = New command
command.Command.Name = "1"
command.Command.Action = "2"
command.Command.Argument = New Argument
command.Command.Argument.Name = "3"
command.Command.Argument.Value = "4"

serializer.Serialize(writer, command)
writer.Close()
Public Class CommandXml

Private m_command As Command

<XmlElement("cmd")> _
Public Property Command() As Command
Get
Return m_command
End Get
Set(ByVal value As Command)
m_command = value
End Set
End Property

End Class

Public Class Command

Private m_name As String
Private m_action As String
Private m_argument As Argument

<XmlAttributeAttribute("name")> _
Public Property Name() As String
Get
Return m_name
End Get
Set(ByVal value As String)
m_name = value
End Set
End Property

<XmlAttributeAttribute("action")> _
Public Property Action() As String
Get
Return m_action
End Get
Set(ByVal value As String)
m_action = value
End Set
End Property

<XmlElement("arg")> _
Public Property Argument() As Argument
Get
Return m_argument
End Get
Set(ByVal value As Argument)
m_argument = value
End Set
End Property

End Class

Public Class Argument

Private m_name As String
Private m_value As String

<XmlAttributeAttribute("name")> _
Public Property Name() As String
Get
Return m_name
End Get
Set(ByVal value As String)
m_name = value
End Set
End Property

<XmlAttributeAttribute("value")> _
Public Property Value() As String
Get
Return m_value
End Get
Set(ByVal value As String)
m_value = value
End Set
End Property

End Class

I find using System.Text.XmlTextWriter to be equally easy. Something like:

Dim writer As New System.Xml.XmlTextWriter("CommandXml.xml",
System.Text.Encoding.UTF8)
writer.Formatting = Xml.Formatting.Indented
writer.Indentation = 1
writer.IndentChar = ControlChars.Tab
writer.WriteStartDocument()

' <CommandXML>
writer.WriteStartElement("CommandXML")

' <cmd name="1" action="2">
writer.WriteStartElement("cmd")
writer.WriteAttributeString("name", "1")
writer.WriteAttributeString("action", "2")

' <arg name="3" value = "4"/>
writer.WriteStartElement("arg")
writer.WriteAttributeString("name", "3")
writer.WriteAttributeString("value", "4")
writer.WriteEndElement() ' arg

' <arg name="5" value = "6"/>
writer.WriteStartElement("arg")
writer.WriteAttributeString("name", "5")
writer.WriteAttributeString("value", "6")
writer.WriteEndElement() ' arg

' </cmd>
writer.WriteEndElement() ' cmd

' <cmd name="7" action="9">
writer.WriteStartElement("cmd")
writer.WriteAttributeString("name", "7")
writer.WriteAttributeString("action", "9")

' <arg name="9" value = "0"/>
writer.WriteStartElement("arg")
writer.WriteAttributeString("name", "9")
writer.WriteAttributeString("value", "0")
writer.WriteEndElement() ' arg

' </cmd>
writer.WriteEndElement() ' cmd

' </CommandXML>
writer.WriteEndElement() ' CommandXML

writer.WriteEndDocument()
writer.Close()

Hope this helps
Jay

"Scott M. Lyon" <sc******************@rapistan.BLUE.com> wrote in message
news:OI**************@TK2MSFTNGP09.phx.gbl...
| Quick (hopefully easy) question for you guys.
|
|
| What is going to be the quickest/easiest way to generate XML from VB.NET?
|
|
| Note: I don't mean an XML file, but XML in memory somehow (an XML-related
| object, but one that would have a method for getting the fully-formed XML
| back out again).
|
|
| For example, what will be my easiest way to build the following in memory:
|
| <CommandXML>
| <cmd name="1" action="2">
| <arg name="3" value = "4"/>
| <arg name="5" value = "6"/>
| </cmd>
| <cmd name="7" action="9">
| <arg name="9" value = "0"/>
| </cmd>
| </CommandXML>
|
|
|
| Basically, the reason I need this in memory, is I need to build this XML,
| then send it (as a string) to a server component.
|
|
| Thanks!
| -Scott
|
|
Nov 12 '05 #3

P: n/a
Hello Scott,

Well, may be I'm simplistic, but if you just want to send a string to a
server, then build the string:

StringBuilder xml=new StringBuilder();
xml.Append("<CommandXML>\n");
xml.Append(" <cmd name=\"1\" action=\"2\">\n");
xml.Append(" <arg name=\"3\" value=\"4\"/>\n");
xml.Append(" <arg name=\"5\" value=\"6\"/>\n");
xml.Append(" </cmd>\n");
xml.Append(" <cmd name=\"7\" action=\"9\">\n");
xml.Append(" <arg name=\"9\" value=\"0\"/>\n");
xml.Append(" </cmd>\n");
xml.Append("</CommandXML>");

Then, when you want to access the string you do a
xml.ToString();

And, if you want to check the Xml you do a:
try {
XmlDocument doc=new XmlDocument();
doc.LoadXml(xml.ToString());
} catch (XmlException e) {
throw new Exception("Error "+e.Message+" in line "+e.LineNumber+"
at\n"+xml.ToString());
}

Hope this helps,
jmgonet
Nov 12 '05 #4

P: n/a
jmgonet wrote:
Well, may be I'm simplistic, but if you just want to send a string to a
server, then build the string:
Bad idea. Then you must take care of XML syntax issues - well-formdness,
escaping special characters, encoding issues etc etc etc. It's always
much better to let XML API to deal with XML.
StringBuilder xml=new StringBuilder();
xml.Append("<CommandXML>\n");


That's a code from 1998. In 2005 you can have a luxury to use XmlTextWriter.

--
Oleg Tkachenko [XML MVP, MCP]
http://blog.tkachenko.com
Nov 12 '05 #5

P: n/a
> That's a code from 1998. In 2005 you can have a luxury to use
XmlTextWriter.
Yes, I get your point :-)

But I have 2 reasons to believe in my very simplistic solution:
- The example Scott provides is a serie of commands. They don't seem to have
any special chars. Special chars like "&", ">" and "<". In his particular
case, he may have no escapes to deal with.
- The resulting code is very "readable".

To deal with escape chars, you can use the following function:

StringBuilder xml=new StringBuilder();
xml.Append("<CommandXML>\n");
xml.Append(" <cmd name=\"1\" action=\"2\">\n");
xml.Append(" <arg name=\"3\"
value=\""+ParseForXml("&<>&&&")+"\"/>\n");
xml.Append(" <arg name=\"5\" value=\"6\"/>\n");
xml.Append(" </cmd>\n");
xml.Append(" <cmd name=\"7\" action=\"9\">\n");
xml.Append(" <arg name=\"9\" value=\"0\"/>\n");
xml.Append(" </cmd>\n");
xml.Append("</CommandXML>");

Then you have to define the ParseForXml method somewhere:

public static string ParseForXML(string str) {
string s;
int n1,n2,n3;
StringBuilder xml;
if (str==null) return "";
if (str.Length==0) return "";
xml=new StringBuilder("");

//.......................... Remplace les "&"
.............................................
// Les "&" sont légaux sous la forme "&amp;", "&lt;" et "&gt;"
// Les "&" sont aussi légaux sous la forme "&#--" et "&#x----"
n3=0;
n1=str.IndexOf("&");
while (n1>=0) {
xml.Append(str.Substring(n3,n1-n3));
n3=n1+1;
n2=str.IndexOf(";",n1);
if (n2>n1) {
s=str.Substring(n1,n2-n1+1);
switch (s) {
case "&amp;":
case "&gt;":
case "&lt;":
xml.Append("&");
break;
default:
if (s[1]=='#')
xml.Append("&");
else
xml.Append("&amp;");
break;
}
} else
xml.Append("&amp;");
n1=str.IndexOf("&",n3);
}
xml.Append(str.Substring(n3));

//................. Remplace les ">" et les "<"
..................................
xml.Replace("<","&lt;");
xml.Replace(">","&gt;");

//................................ Et voilà
......................................
return xml.ToString();
}

Of course, if the Xml data you have to write has external namespaces, really
complex Unicode chars, etc, it may get tricky. And, truely, the
XmlTextWriter may be a nice solution:

xml=new StringBuilder();
sw=new StringWriter(xml);
xtw=new XmlTextWriter(sw);
xtw.WriteStartDocument(true);
xtw.WriteStartElement("CommandXML");
xtw.WriteStartElement("cmd");
xtw.WriteAttributeString("name","1");
xtw.WriteAttributeString("action","2");
xtw.WriteStartElement("arg");
xtw.WriteAttributeString("name","3");
xtw.WriteAttributeString("value","4");
xtw.WriteEndElement();
xtw.WriteStartElement("arg");
xtw.WriteAttributeString("name","5");
xtw.WriteAttributeString("value","6");
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.WriteStartElement("cmd");
xtw.WriteAttributeString("name","7");
xtw.WriteAttributeString("action","9");
xtw.WriteStartElement("arg");
xtw.WriteAttributeString("name","9");
xtw.WriteAttributeString("value","0");
xtw.WriteEndElement();
xtw.WriteEndElement();
xtw.WriteEndDocument();

XmlDocument doc=new XmlDocument();
doc.LoadXml(xml.ToString());

But I think is poorly readable. And I still prefere the simple way. After
all Scott was asking for the "simplest".

"Oleg Tkachenko [MVP]" <oleg@NO!SPAM!PLEASEtkachenko.com> wrote in message
news:O%******************@TK2MSFTNGP09.phx.gbl...
jmgonet wrote:
Well, may be I'm simplistic, but if you just want to send a string to a
server, then build the string:
Bad idea. Then you must take care of XML syntax issues - well-formdness,
escaping special characters, encoding issues etc etc etc. It's always
much better to let XML API to deal with XML.
StringBuilder xml=new StringBuilder();
xml.Append("<CommandXML>\n");


That's a code from 1998. In 2005 you can have a luxury to use

XmlTextWriter.
--
Oleg Tkachenko [XML MVP, MCP]
http://blog.tkachenko.com

Nov 12 '05 #6

P: n/a
jmgonet,
As Oleg suggests using a StringBuilder is a "bad" idea. In addition to the
reasons Oleg states. Item #29 "Always Use a Parser" from Elliotte Rusty
Harold's book "Effective XML - 50 Specific Ways to Improve Your XML" from
Addison Wesley lists a number of other reasons to use a parser. Although
Item #29 is largely reading, I find the topic apropos to writing also.

Hope this helps
Jay
"jmgonet" <jm*****@yahoo.com> wrote in message
news:42**********************@news.sunrise.ch...
| Hello Scott,
|
| Well, may be I'm simplistic, but if you just want to send a string to a
| server, then build the string:
|
| StringBuilder xml=new StringBuilder();
| xml.Append("<CommandXML>\n");
| xml.Append(" <cmd name=\"1\" action=\"2\">\n");
| xml.Append(" <arg name=\"3\" value=\"4\"/>\n");
| xml.Append(" <arg name=\"5\" value=\"6\"/>\n");
| xml.Append(" </cmd>\n");
| xml.Append(" <cmd name=\"7\" action=\"9\">\n");
| xml.Append(" <arg name=\"9\" value=\"0\"/>\n");
| xml.Append(" </cmd>\n");
| xml.Append("</CommandXML>");
|
| Then, when you want to access the string you do a
| xml.ToString();
|
| And, if you want to check the Xml you do a:
| try {
| XmlDocument doc=new XmlDocument();
| doc.LoadXml(xml.ToString());
| } catch (XmlException e) {
| throw new Exception("Error "+e.Message+" in line "+e.LineNumber+"
| at\n"+xml.ToString());
| }
|
| Hope this helps,
| jmgonet
|
|
Nov 12 '05 #7

P: n/a
jmgonet wrote:
But I have 2 reasons to believe in my very simplistic solution:
- The example Scott provides is a serie of commands. They don't seem to have
any special chars. Special chars like "&", ">" and "<".


Not only these. What about " within an attribute value, delimited by ""?
Or ' within an attribute value delimited by ''? What about -- within a
comment? There are lots of tricky cases you better never touch, because
that's XML API responsibility to hide them from you.

Sure you can build XML with no XML API, but then don't be surprised if
your application fails in production when user enters ♫ character in a
form.

So despite your approach looks simpler, it's more complex, becuase it's
too fragile you'd need to fix it all the time.
--
Oleg Tkachenko [XML MVP, MCP]
http://blog.tkachenko.com
Nov 12 '05 #8

This discussion thread is closed

Replies have been disabled for this discussion.