O Visual Studio 2010 introduz suporte para utilização de objectos de linguagens dinâmicas, como IronPython ou IronRuby, e a criação de objecto dinâmicos, dentro da própria linguagem (VB ou C#). Isto torna possível a inclusão de métodos dinâmicos em linguagens estáticas, como são o VB.NET ou C#, através da Dynamic Language Runtime (DLR).
No caso do Visual Basic, isto permite outra forma, que não usando o tipo Object, de se ligar a objecto dinâmicos em latebind, ou seja, sem que o compilador tente interpretar o código e dê erro, sendo o código interpretado em modo de execução(run-time). Mais informação e vantagens sobre ambos os métodos: Early and Late Binding
Desta forma podemos em alguns casos, com a devida manipulação é claro, utilizar um sintaxe mais agradável, ou seja, não fazer:
Dim reader As SqlClient.SqlDataReader = command.ExecuteReader()
Me.txtNome.Text = reader.Item("nome")
Me.txtMorada.Text = reader.Item("morada")
Me.txtTelefone.Text = reader.Item("telefone")
Mas sim algo mais simples (uma vez que em ambos os casos não temos intellisense):
Dim reader As Object = New DynamicCommand(command)
Me.txtNome.Text = reader.nome
Me.txtMorada.Text = reader.morada
Me.txtTelefone.Text = reader.telefone
Isto consegue-se utilizando a classe DynamicObject(), do namespace System.Dynamic, permitindo a criação de objectos dinâmicos. De uma forma geral, podemos criar uma nova classe, que herda as propriedades e métodos do DynamicObject(), e através dos métodos TryGetMember() e TrySetMember() podemos identificar se estamos a definir uma propriedade ou a verificar o valor de uma propriedade. Existem mais métodos disponíveis, mas para o seguinte exemplo, iremos apenas utilizar estes dois.
Este pequeno exemplo irá guardar uma propriedade e depois verificar o seu valor. Bastante simples apenas para se entender o funcionamento geral.
Definição da classe dinâmica:
Public Class DynamicObjectTest
Inherits DynamicObject
Private m_dictionary As New Dictionary(Of String, Object)
''' <summary>
''' Verifica no Dictionary o valor guardado
''' </summary>
''' <returns></returns>
''' <remarks></remarks>
Public Overrides Function TryGetMember(
ByVal binder As GetMemberBinder,
ByRef result As Object) As Boolean
result = m_dictionary.Item(binder.Name.ToLower)
Return True
End Function
''' <summary>
''' Adiciona o nome e o valor no Dictionary
''' </summary>
''' <returns></returns>
''' <remarks></remarks>
Public Overrides Function TrySetMember(
ByVal binder As System.Dynamic.SetMemberBinder,
ByVal value As Object) As Boolean
m_dictionary.Add(binder.Name.ToLower, value)
Return True
End Function
End Class
Depois, criando uma nova instância e adicionado alguns valores:
' Cria uma nova instância da classe DynamicObjectTest
Dim myDynamicObject As Object = New DynamicObjectTest()
' Adiciona uma nova label (com algumas definições)
myDynamicObject.CustomObject = New Label() With
{
.Text = "Teste",
.Name = "lblTeste",
.Location = New Point(10, 10)
}
' Adiciona uma mensagem
myDynamicObject.Msg = "Dynamic Object Test"
Finalmente, a verificação e utilização dos valores guardados:
' Adiciona ao Form a label
Me.Controls.Add(myDynamicObject.CustomObject)
' Define como texto do Form a mensagem guardada
Me.Text = myDynamicObject.Msg
Uma funcionalidade que promete, que para além de permitir utilizar linguagens dinâmicas no VB.NET ou no C#, o que poderá trazer grandes vantagens, permite ainda criar objectos dinâmicos que podem ser utilizados na própria linguagem (onde aqui poderá ter menos utilização), ou mesmo em linguagens externas (desde que tenham suporte DLR)
Já está disponível a MSDN Magazine de Março de 2010
Nesta edição é possível ler diversos artigos como:
Entre outras! Para os leitores de Visual Basic, duas colunas que gostaria de destacar: | .png) |
A não perder!
Um artigo anterior, publicado neste blog, foi dedicado a Lambda Expressions, explicando de um modo geral o seu funcionamento e o seu sintaxe.
Com a chegada do Visual Studio 2010, algumas das limitações que existiam e que já estavam disponível no C# 3.0, foram introduzidas, já sendo agora possível criar expressões em múltiplas linhas e expressões que não retornam resultados.
Podemos então criar lambda expressions em uma linha ou em várias linhas:
' Função single-line
Dim result1 = Function(x) x * x
' Função multi-line
Dim result2 = Function(x)
Return (x * x)
End Function
' Mostra os resultados
Debug.WriteLine(result1(5))
Debug.WriteLine(result2(5))
E podemos também criar lambda expressions que não retornam resultados, substituindo a keyword Function() por Sub():
' Subrotina single-line
Dim showResult1 = Sub(result As Integer) Debug.WriteLine(result.ToString())
' Subrotina multi-line
Dim showResult2 = Sub(result As Integer)
Debug.WriteLine(result.ToString())
End Sub
' Mostrando os resultados
showResult1(12345)
showResult2(12345)
Mais alguns exemplos, um pouco mais complexos, de como podemos criar expressões em várias linhas, com diferentes validações e retornando ou não resultados:
Dim listValues As New List(Of Integer) From
{1, 2, 3, 4, 5, 6, 7, 8}
' Irá mostrar os resultados com diferentes outputs para
' os números superiores, inferiores e iguais a 5
Array.ForEach(listValues.ToArray,
Sub(x)
If x > 5 Then
Debug.WriteLine(x.ToString & " é maior que 5")
ElseIf x = 5 Then
Debug.WriteLine(x.ToString & " é o número certo")
Else
Debug.WriteLine(x.ToString & " é menor que 5")
End If
End Sub)
' Irá mostrar os resultados e irá colocar na variável 'result', todos os
' números superiores a 5, ou seja, criará um array com os número 6, 7 e 8
Dim result = Array.FindAll(listValues.ToArray,
Function(x)
Debug.WriteLine(x)
Return x > 5
End Function)
Mais algumas melhorias que vêm ajudar a tornar as lambda expressions mais versáteis e com cada vez com mais aplicação!
Collection Initializers é um método simples de adicionar alguns dados a uma colecção, usando a keyword From, seguida de chavetas curvas { }. Esta opção é útil quando alguns dados de uma colecção são sempre os mesmos ou quando existem algumas constantes na colecção.
Por exemplo, para se criar um array simples com alguns dados em Visual Studio 2010:
Dim numbers = {1, 2, 3, 4, 5}
Dim sexo = {"masculino", "feminino"}
Estes são exemplos simples, que também poderiam ser criados em versões anteriores, como VS2005 ou VS2008, embora com um sintaxe um pouco diferente, indicando que se tratavam de arrays:
' Exemplo em Visual Studio 2008
Dim numbers() = {1, 2, 3, 4, 5}
Dim sexo() = {"masculino", "feminino"}
Mas vejamos o caso de colecções, neste caso uma List(Of T):
Dim listaSexos As New List(Of String) From {"Masculino", "Feminino"}
Em versões anteriores poderia ser feito da seguinte forma:
' Exemplo em Visual Studio 2008
Dim listaSexos As New List(Of String)
listaSexos.Add("Masculino")
listaSexos.Add("Feminino")
' ou, como se trata de strings, usando um array
listaSexos.AddRange(New String() {"Masculino", "Feminino"})
Podemos também usar os collection Initializers com classes, neste caso, com uma classe simples de estudantes:
Public Class Student
Public Property Name As String
Public Property Age As Int16
Sub New(ByVal _Name As String, ByVal _Age As Int16)
Name = _Name
Age = _Age
End Sub
End Class
Depois, criando uma nova instancia e indicando alguns dados:
Dim students = New List(Of Student) From
{
New Student("Jorge", 35),
New Student("Ana", 30),
New Student("Paula", 25)
}
Em suma, os collection Initializers são métodos simples de se inicializar colecções que visam, uma vez mais, simplificar o código!
