Porque eu adoro VB: XML Literals

O Visual Basic ganhou na versão 9 os XML Literals. Um literal é algo muito simples, é uma maneira de criar um tipo sem precisar escrever New AlgumaClasse(“algum parametro”). Por exemplo, strings possuem literais:

dim valor = "Ola"

Nesse exemplo, valor é inferido como string.

E a mesma coisa existe para xml. Sim, xml possuem literais. Você pode fazer isso:

Dim xml = <elemento>
          </elemento>

E vai ser compreendido. Quer mais, ele reconhece o tipo pela formação do XML. O exemplo acima gera uma classe XElement. Veja o teste:

<TestMethod()>
Public Sub IssoEhUmXElement()
    'act
    Dim xml = <elemento>
              </elemento>
    'assert
    Assert.IsInstanceOfType(xml, GetType(XElement))
End Sub

Mas se você colocar o header do XML, o tipo muda para XDocument:

<TestMethod()>
Public Sub IssoEhUmXDocument()
    'act
    Dim xml = <?xml version="1.0" encoding="utf-8"?>
              <elemento>
              </elemento>
    'assert
    Assert.IsInstanceOfType(xml, GetType(XDocument))
End Sub

Esperto, né?

Quer ver ficar mais legal? Você pode importar um namespace XML, além de namespaces .Net. Aqui importei o de mapeamento do NHibernate:

Imports <xmlns="urn:nhibernate-mapping-2.2">

E usar esse import nos métodos. Veja só:

<TestMethod()>
Public Sub ConsigoObterItens()
    'act
    Dim xml = <?xml version="1.0" encoding="utf-8"?>
              <hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
                  <class name="Pessoa">
                      <id name="id">
                          <generator class="native"/>
                      </id>
                      <property name="Nome"/>
                      <property name="Sobrenome"/>
                      <property name="Idade" type="System.Int32"/>
                  </class>
              </hibernate-mapping>

    'assert
    Dim classe1 = xml...<class>.FirstOrDefault()
    Assert.IsNotNull(classe1)
    Assert.AreEqual("Pessoa", classe1.@name)
    Assert.AreEqual("id", classe1.<id>.Single.@name)
    Assert.AreEqual("id", classe1.<id>.Single.@name)
    Assert.AreEqual(3, classe1.<property>.Count)
    Assert.IsNull(classe1.<property>.Skip(1).Take(1).Single.@type)
    Assert.AreEqual("System.Int32", classe1.<property>.Skip(2).Take(1).Single.@type)
End Sub

Viram que dá pra trabalhar expressões como “classe1.<id>.Single.@name”? Quer coisa mais legal? Dá pra aplicar Linq também. Aquela linha que define a variável classe1 pode ser trocada por esse linq (com um where a mais pra dar uma ideia):

Dim classe1 = (From x In xml.<hibernate-mapping>.<class>
               Where x.@name = "Pessoa"
               Select x).Single

E que tal criar o XML do zero, a partir de um objeto, com direito a loop e tudo. Veja só, nesse exemplo, em vez de fazer o xml hard coded, eu o crio com outros dados, referenciando propriedades de uma classe anônima, e inclusive itero pela propriedade “propriedades”, que retorna uma lista:

<TestMethod()>
Public Sub ConsigoCriarMapeamento()
    'arrange
    Dim mapeamento = 'prepara uma classe anônima (oculto)

    'act
    Dim xml = <?xml version="1.0" encoding="utf-8"?>
              <hibernate-mapping xmlns="urn:nhibernate-mapping-2.2">
                  <class name=<%= mapeamento.name %>>
                      <id name=<%= mapeamento.id.name %>>
                          <generator class=<%= mapeamento.id.generator.class %>/>
                      </id>
                      <%= From p In mapeamento.properties
                          Select <property name=<%= p.Name %> type=<%= p.Type %>/>
                      %>
                  </class>
              </hibernate-mapping>

    'asserts igual os outros...
End Sub

Não tem coisa mais legal.

É por isso que eu adoro o VB.