Quando uma linha de código é demasiado extensa, é necessário muitas vezes saltar de linha, de modo a que o código fique todo visível e seja mais simples de interpretar. Para o fazer é usado um “_” (underscore):
MessageBox.Show("Isto é um teste", _
My.Application.Info.Title, _
MessageBoxButtons.OK, _
MessageBoxIcon.Warning)
Ora isto é algo que no Visual Studio 2010 deixou de ser necessário, podendo agora ser utilizado:
MessageBox.Show("Isto é um teste",
My.Application.Info.Title,
MessageBoxButtons.OK,
MessageBoxIcon.Warning)
Obviamente que isto não pode ser efectuado em todas as situações, pois o compilador precisa de saber identificar se estamos a saltar de linha ou a iniciar uma nova instrução.
Estas são algumas das situações onde é possível o fazer:
- Após uma virgula “,”
- Após um parêntese aberto “(“ ou antes de um fechado “)”
- Após uma chaveta recta “{“ ou antes de uma chaveta recta “}”
- Após uma concatenação “&”
- Após uma atribuição “=, &=, :=, +=, -=, *=, /=, \=, ^=, <<=, >>=”
- Após um operador binário “+, -, /, *, Mod, <>, <, >, <=, >=, ^, >>, <<, And, AndAlso, Or, OrElse, Like, Xor”
- Após um operador Is ou IsNot
Entre muitas outras situações, como LINQ, XML Literals, etc.
Mais uma melhoria com o objectivo de simplificar a vida ao programador!
As Auto-Implemented Properties são uma forma simples e rápida de definir uma propriedade, sem a utilização do Get e Set. Esta opção já estava disponível no C# 3.0 e passou agora a fazer parte do VB10.
Podemos agora fazer(auto-implemented property):
Public Property myProp As String
Em vez de(expanded property):
Private _myPror As String
Public Property myPror() As String
Get
Return _myPror
End Get
Set(ByVal value As String)
_myPror = value
End Set
End Property
No entanto pode-se sempre usar o método “normal”(expanded property), caso seja necessário adicionar código nos métodos Get e Set, caso seja uma propriedade WriteOnly ou ReadOnly, etc.
Quando é definida uma auto-implemented property, é criado internamente (não visível) um backing field, ou seja, se a propriedade for designada como “myProp”, será criada uma variável “_myProp”. Isto quer dizer, que se tentarmos criar uma variável com o mesmo nome, iremos ter o seguinte erro:
property 'myProp' implicitly defines '_myProp', which conflicts with a member of the same name in class 'Form1'
Podemos ainda inicializar a propriedade por mais complexa que seja a expressão:
Public Property myProp1 As String = "vbtuga"
Public Property myProp2 As Integer = 123
Public Property myProp3 As List(Of Integer) = Enumerable.Range(0, 20).ToList
Public Property myProp4() As String = New String({"a", "b", "c"})
Sem dúvida vem ajudar a simplificar o código!
Com o lançamento da versão Visual Studio 2010 Release Candidate e com o lançamento da versão final à vista, existem obviamente um conjunto de novidades do Visual Studio 2010 e da plataforma .NET Framework 4.
Estas novidades vêm aproximar ainda mais o VB.NET e o C#, pois algumas das coisas que estavam disponíveis apenas no VB.NET, estão agora disponíveis no C# (como os Optional Parameters), e algumas das coisas que estavam apenas disponíveis no C#, estão agora disponíveis no VB.NET (como as Auto-Implemented Properties ou as Multiline Lambda Expressions).
Luca Bolognese, Principal Group Program Manager para as linguagens C#, VB e F#, compiladores e IDEs , fala no Channel 9 sobre C# and VB.NET Co-Evolution, onde refere que as duas linguagens estão cada vez mais próximas e que no desenvolvimento de novas versões, irão ser implementadas novidades em ambas as linguagens e não apenas em uma ou outra. Esta versão do Visual Studio é o resultados disso mesmo!
Existem diversas aplicações online e offline que garantem a conversão de grande parte do código e, com as alterações que juntam cada vez mais as duas linguagens, a taxa de sucesso na conversão será ainda maior.
Podemos deste modo crer, que em edições futuras poderá ser possível mudar a linguagem da aplicação, dentro do próprio Visual Studio, ou seja, poderemos ter programadores de VB.NET e C# a trabalhar na mesma aplicação.
Isto poderia até ser relevante para o mercado de trabalho, uma vez que não existiriam vagas para um programador de VB ou para um programador de C#, mas sim para um programador da plataforma .NET. Será isto possível no futuro próximo? Será isto uma realidade nas próximas versões? O futuro o dirá!
Os próximos artigos deste blog irão focar algumas das novidades do Visual Studio 2010, algumas mais simples e algumas mais complexas, mas sempre em VB.NET!
Esta classe, SqlTransaction(), não é uma novidade das últimas versões da plataforma .NET, mas mesmo assim, não é usada por muitos programadores, sendo ela tão útil para comandos T-SQL dependentes.
Numa perspectiva geral, é criado um objecto SqlTransaction() chamando o método BeginTransaction() da classe SqlConnection(). A partir daqui, todas as operações são efectuadas na SqlTransaction() e, chamando o método Commit(), irá tentar executar todas as operações na base de dados SQL. Caso não consiga, pode-se então chamar o método Rollback() que irá tentar anular todas as alterações planeadas.
Imaginemos que queremos inserir os dados de um formulário em tabelas diferentes, ou seja, alguns dados vão para uma tabela e outros dados para outra(s) tabela(s). Estes dados têm de estar relacionados(ID) caso contrário não existe correspondência entre eles. O facto de não se conseguir escrever em qualquer uma das tabelas, pode assim comprometer a integridade dos dados.
Fica aqui um pequeno exemplo de como podemos evitar este problema:
Dim connString As String = "connection string de ligação ao SQL"
Dim transaction As SqlClient.SqlTransaction = Nothing
' Ligação à base de dados
Using conn As New SqlClient.SqlConnection(connString)
conn.Open()
Try
' Define o comando e a transacção
Using command As SqlClient.SqlCommand = conn.CreateCommand()
transaction = conn.BeginTransaction
' Faz diversas operações em diferentes tabelas, usando
' comandos T-SQL(UPDATE e INSERT), StoredProcedures, etc
With command
' Define a ligação e transacção para o SqlCommand
.Connection = conn
.Transaction = transaction
' ---------------------------------------------------------
' Actualiza a 1ª tabela (Tabela 1)
' ---------------------------------------------------------
.CommandType = CommandType.Text
.CommandText = "UPDATE tabela1 SET anulado=1 WHERE id=@id;"
.Parameters.Add("@id", SqlDbType.Int).Value = 123
.ExecuteNonQuery()
.Parameters.Clear()
' ---------------------------------------------------------
' Insere a 2ª tabela (Tabela 2) neste caso através
' de um StoredProcedure e o método ExecuteScalar()
' ---------------------------------------------------------
.CommandType = CommandType.StoredProcedure
.CommandText = "sp_tabela2"
.Parameters.Add("@a", SqlDbType.VarChar).Value = "abc"
.Parameters.Add("@b", SqlDbType.VarChar).Value = "def"
Dim lastID As Integer = Integer.Parse(.ExecuteScalar())
.Parameters.Clear()
' ---------------------------------------------------------
' Insere na 3ª tabela (Tabela 3) usando o resultado anterior
' ---------------------------------------------------------
.CommandType = CommandType.Text
.CommandText = "INSERT INTO tabela3 (ID) VALUES (@ID)"
.Parameters.Add("@ID", SqlDbType.Int).Value = lastID
.ExecuteNonQuery()
End With
' Tenta gravar as actualizações na base de dados
transaction.Commit()
MessageBox.Show("Actualização efectuada com sucesso!")
End Using
Catch ex As Exception
Try
' Caso ocorra um erro tenta fazer o Rollback() ou
' seja, cancelar as modificações que estão pendentes
transaction.Rollback()
Exit Try
Catch ex2 As Exception
MessageBox.Show(ex2.Message)
End Try
' Informação geral do erro, mas com as modificações já canceladas
MessageBox.Show(ex.Message)
End Try
End Using
transaction.Dispose()
Simples de utilizar, e muito útil, garantido desta forma que todas as transacções são efectuadas, e caso contrário, serão canceladas, não ficando assim, dados sem correspondência.
