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.

Giovanni Bassi

Arquiteto e desenvolvedor, agilista, escalador, provocador. É fundador e CSA da Lambda3. Programa porque gosta. Acredita que pessoas autogerenciadas funcionam melhor e por acreditar que heterarquia é mais eficiente que hierarquia. Foi reconhecido Microsoft MVP há mais de dez anos, dos mais de vinte que atua no mercado. Já palestrou sobre .NET, Rust, microsserviços, JavaScript, TypeScript, Ruby, Node.js, Frontend e Backend, Agile, etc, no Brasil, e no exterior. Liderou grupos de usuários em assuntos como arquitetura de software, Docker, e .NET.