Já que estamos falando de literals, o Visual Basic tem algo muito legal que o C# não tem: Date Literals. Olha como eu escrevo uma data no VB:

<TestMethod()>
Public Sub ConsigoCriar13DeOutubro()
    'act
    Dim data = #10/13/2010#
    'assert
    Assert.AreEqual(New Date(2010, 10, 13), data)
End Sub

Horas também funcionam:

<TestMethod()>
Public Sub ConsigoCriar10E15()
    'act
    Dim data = #10:15:00 AM#
    'assert
    Assert.AreEqual(Date.MinValue.AddHours(10).AddMinutes(15), data)
End Sub

Com ou sem AM e PM. Aqui está no formato de 24 horas:

<TestMethod()>
Public Sub ConsigoCriar13E15()
    'act
    Dim data = #13:15:00#
    'assert
    Assert.AreEqual(Date.MinValue.AddHours(13).AddMinutes(15), data)
End Sub

E dá pra juntar os dois:

<TestMethod()>
Public Sub ConsigoCriar13DeOutubro10E15()
    'act
    Dim data = #10/13/2010 10:15:00 AM#
    'assert
    Assert.AreEqual(New Date(2010, 10, 13).AddHours(10).AddMinutes(15), data)
End Sub

Prático, né? A outra forma aparece no Assert, não fica nem um pouco elegante. Sinto falta disso no C#, principalmente por causa dos testes.

É por isso que eu adoro o VB.

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.

Chegou a mim uma triste notícia. Com o progresso da linguagem Visual Basic diversos caracteres underscore, também conhecidos como underline, estão ficando desempregados. Agora que as continuações de linha do VB são implícitas, os underscores se tornaram opcionais, ou seja, estão todos no olho da rua.

Há até uma ONG para ajudar os coitados a arranjarem emprego. Visite e faça a sua parte.

Lamentável que a Microsoft tome uma atitude como essa, só para tornar a vida de todos os programadores de VB mais fácil. O que esperar agora? Vão matar as chaves do C#?