I'm afraid that I have an apology to make. I feel that I've given my
Visual Basic friends a raw deal because the verses of my
carol thus far have
been primarily about C#. Oh sure, the verses usually end with a paragraph or two
mentioning how a particular refactoring works in VB, but I haven't devoted a
whole verse exclusively to a
Visual Basic 9 feature. Until now. Today's verse is
dedicated specifically to the coolest new feature of
Visual Basic 9:
XML
Literals.
So, sit back and relax. It's time for a little Visual Basic
X-mas cheer!
"On the tenth day of X-mas my true love (DevExpress)
gave to me..."
Refactoring in XML Literals
A couple of months ago, I wrote about how we were adding first-class
refactoring support for Visual Basic XML Literals. If you're unfamiliar with XML
Literals, they allow developers to embed XML directly into their code like
so:
Module TwelveDaysOfXmas
Sub Main()
Dim lBook = <book isbn="12252007">
<title>Refactoring: The True Meaning of X-mas</title>
<price><%=
0D.ToString("C") %></price>
<author>
<first-name>Dustin</first-name>
<last-name>Campbell</last-name>
</author>
</book>
End Sub
End Module
It's the VB Compiler's job to transform the above XML Literal into instances of XElements, XAttributes and XNames from the System.Xml.Linq namespace.
Module TwelveDaysOfXmas
Sub Main()
Dim lBook = New XElement("book", _
New XAttribute("isbn", "12252007"), _
New XElement("title", "Refactoring: The True Meaning of X-mas"), _
New XElement("price", 0D.ToString("C")), _
New XElement("author", _
New XElement("first-name", "Dustin"), _
New XElement("last-name", "Campbell")))
End Sub
End Module
The real power of XML Literals is the ability to embed expressions directly
into the XML. In the first code example above, the <price> tag contains an
embedded expression.
<price><%=
0D.ToString("C") %></price>
Embedded expressions open the door to dynamic XML generation. Very, very
cool.
The only real problem that I have with XML Literals is that embedded
expressions are such a pain to write. Not only does the expression itself have
to be written, but the delimiters contain no less than five
symbols. Granted, VB's IntelliSense fills in the last two after I've typed the
first three, but that's still three characters to type with
the shift key held down. That's pretty painful. It would be great if a refactoring
tool existed that handled this work for us. Oh wait. I work on a refactoring
tool that does that very thing. That's right,
Refactor! Pro
works on XML Literals!
Check out the preview hint for Introduce Local when the contents of the
<title> tag are selected:
And here's the code after Introduce Local is applied:
Visual Basic developers everywhere can rejoice. You no longer have to type
<%= again because the
bread-and-butter refactorings work in XML Literals!
View Screencast
of XML Literal Refactoring in Action!
Tomorrow: more refactorings for XML Literals. You won't want to miss it!