As novidades do Visual Basic 2005

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Confira neste artigo: As novidades do Visual Basic 2005.

Estamos no ano do Visual Basic 2005, já é hora de conhecermos mais a fundo as novidades que estão por vir. Vamos então direto ao assunto.

Partial types

Partial types é um recurso adicionado na síntaxe da orientação a objetos que permite uma utilização bem mais ampla do famoso code-behind que já estavamos acostumados a utilizar em ASP 3.

A palavra Partial pode ser adicionada a uma classe, permitindo que o código da classe seja dividido em duas partes. Assim sendo, se temos uma classe grande, podemos dividi-la em vários arquivos utilizando a palavra partial. No momento da compilação o compilador vai juntar tudo e interpretar como uma única classe.

Veja um exemplo do código interno de um form separado do código da aplicação com a palavra chave Partial :

Partial Public Class Form1
    Inherits System.Windows.Forms.Form

    _
    Public Sub New()
        MyBase.New()
         'This call is required by the Windows Form Designer.
        InitializeComponent()
    End Sub

    'Form overrides dispose to clean up the component list.

    _
    Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
        If disposing AndAlso components IsNot Nothing Then
            components.Dispose()
        End If

        MyBase.Dispose(disposing)
    End Sub

    'Required by the Windows Form Designer

    Private components As System.ComponentModel.IContainer

    'NOTE: The following procedure is required by the Windows Form Designer

    'It can be modified using the Windows Form Designer. 

    'Do not modify it using the code editor.

    _
    Private Sub InitializeComponent()
        '
        'Form1
        '
        Me.AutoScaleBaseSize = New System.Drawing.Size(5, 13)
        Me.ClientSize = New System.Drawing.Size(427, 410)
        Me.Name = "Form1"
        Me.Text = "Form1"
    End Sub

End Class

  

Níveis de acesso mistos

Isso é um recurso que faltou no VB.NET 2003 e agora está sendo trazido de volta (sim, de volta, pois VB 6 tinha).

Digamos que vamos criar uma propriedade com valor calculado, INSS, por exemplo. Desejaremos que esta propriedade seja somente de leitura.

Mas internamente pode ser útil que seja possível a escrita na propriedade INSS, para permitir a realização de cálculos. Neste caso o GET e o SET da propriedade passam a ter visibilidades distintas : Enquanto o GET é público, o SET é privado ou protected.

    Public Property inss() As Decimal
        Get 

        End Get
        Protected Set(ByVal value As Decimal) 

        End Set
    End Property

  

Bloco using

O Blogo usign se assemelha muito ao bloco try/finally, mas com uma síntaxe mais enxuta. Através do bloco using podemos definir variáveis que serão usadas em um pequeno trecho de código e que depois serão eliminadas, sendo chamado o dispose nos casos em que o objeto implementar a interface Idisposable.

        Using cn As New OleDb.OleDbConnection, cmd As New OleDb.OleDbCommand(cn)
            cn.ConnectionString = ""
            cmd.CommandText = ""
            cmd.ExecuteNonQuery()
            cn.Close()
        End Using

Custom events

Os eventos definidos em uma classe permitem que o usuário da classe associe tratadores de eventos utilizando a instrução addhandler, bem como também permitem que o usuário remova tratadores de evento utilizando o remove handler.

Um evento pode ter diversos tratadores de evento, um único tratador de evento ou nenhum tratador de evento.

Então, o que é um Custom event ? Um Custom Event é uma nova síntaxe de criação de eventos que permite que o programador personalize o processo de adição de um tratador de eventos, a exclusão de um tratador de eventos e o processo de disparo de um evento.

Existem 2 motivos principais para que se deseje personalizar um evento : otimizar o consumo de memória e permitir processamento assíncrono. Vamos falar dos dois motivos separadamente.

Otimizar o consumo de memória

Para cada evento tradicional de uma classe o .NET mantém em memória uma variável para guardar os tratadores de eventos desta classe. Se uma classe tem 10 eventos, mesmo que os 10 não estejam sendo utilizados haverão em memória 10 variáveis controlando os 10 eventos.

Utilizando custom events esse processo pode ser otimizado, reduzindo o consumo de memória. Por exemplo, podemos criar uma única variável para guardar os tratadores de todos os eventos da classe, economizando assim 9 variáveis.

Veja abaixo um exemplo simples. Este exemplo apenas permite um único tratador de evento por evento. Veja o código :

 

Public Class MemoryOptimizedBaseControl
    ' Define a delegate store for all event handlers.
    Private Events As New System.ComponentModel.EventHandlerList

     ' Define the Click event to use the delegate store.
    Public Custom Event Click As EventHandler
        AddHandler(ByVal value As EventHandler)
            Events.AddHandler("ClickEvent", value)
        End AddHandler

        RemoveHandler(ByVal value As EventHandler)
            Events.RemoveHandler("ClickEvent", value)
        End RemoveHandler

        RaiseEvent(ByVal sender As Object, ByVal ea As EventArgs)
            CType(Events("ClickEvent"), EventHandler).Invoke(sender, ea)
        End RaiseEvent
    End Event

    ' Define the Click event to use the same delegate store.
    Public Custom Event DoubleClick As EventHandler
        AddHandler(ByVal value As EventHandler)
            Events.AddHandler("DoubleClickEvent", value)
        End AddHandler

        RemoveHandler(ByVal value As EventHandler)
            Events.RemoveHandler("DoubleClickEvent", value)
        End RemoveHandler

        RaiseEvent(ByVal sender As Object, ByVal ea As EventArgs)
            CType(Events("DoubleClickEvent"), EventHandler).Invoke(sender, ea)
        End RaiseEvent
    End Event

    ' Define additional events to use the same delegate store.
    ' ...
End Class

 

Permitir execução assíncrona

Quando existem diversos tratadores de evento para um mesmo evento, os tratadores são chamados sequencialmente. Essa chamada sequencial pode prejudicar a performance da aplicação e tarefas mais críticas.

Criando um custom event e personalizando o processo de disparo dos tratadores podemos fazer com que todos os tratadores de um determinado evento sejam disparados em paralelo de forma assíncrona, ao invés de serem disparados sequencialmente.

Veja como fica o código :
 

Public NotInheritable Class ReliabilityOptimizedControl
    'Defines a list for storing the delegates

    Private EventHandlerList As New ArrayList

    'Defines the Click event using the custom event syntax.
    'The RaiseEvent always invokes the delegates asynchronously

    Public Custom Event Click As EventHandler
        AddHandler(ByVal value As EventHandler)
            EventHandlerList.Add(value)
        End AddHandler

        RemoveHandler(ByVal value As EventHandler)
            EventHandlerList.Remove(value)
        End RemoveHandler

        RaiseEvent(ByVal sender As Object, ByVal ea As EventArgs)
            For Each handler As EventHandler In EventHandlerList
                If handler IsNot Nothing Then
                    handler.BeginInvoke(sender, ea, Nothing, Nothing)
                End If
            Next
        End RaiseEvent
    End Event
End Class

Juntando tudo

Claro que podemos implementar os dois recursos em uma única classe, fazendo com que os eventos gerem economia de memória e disparo assíncrono. Veja como fica o código :

Public NotInheritable Class ReliabilityOptimizedControl
    'Defines a list for storing the delegates

    Private ListaEventos As New hashtable

    'Defines the Click event using the custom event syntax.
    'The RaiseEvent always invokes the delegates asynchronously

    Public Custom Event Click As EventHandler
        AddHandler(ByVal value As EventHandler)
            Dim el As arrayList

            If isnothing(listaeventos("Click")) Then
                el = New arraylist
                listaeventos.add("Click", el)
            Else
                el = listaeventos("Click")
            End If

            el.Add(value)
            listaeventos("Click") = el
        End AddHandler

        RemoveHandler(ByVal value As EventHandler)
            Dim el As arraylist

            If isnothing(listaeventos("Click")) Then
                el = New arraylist
                listaeventos.add("Click", el)
            Else
                el = listaeventos("Click")
            End If

            el.Remove(value)
        End RemoveHandler

        RaiseEvent(ByVal sender As Object, ByVal ea As EventArgs)
            Dim el As arraylist

            If isnothing(listaeventos("Click")) Then
                el = New arraylist
                listaeventos.add("Click", el)
            Else
                el = listaeventos("Click")
            End If

            For Each handler As EventHandler In el
                If handler IsNot Nothing Then
                    handler.BeginInvoke(sender, ea, Nothing, Nothing)
                End If
            Next
        End RaiseEvent
    End Event
End Class

 

Generics

A melhor forma de compreendermos a necessidade dos Generics é analisando o processo de criação de uma coleção fortemente tipada.

Para criarmos uma coleção precisamos fazer uma herança da classe collectionBase. Veja um pequeno exemplo de como fica :
 

Public Class ColecaoFuncionarios
    Inherits system.Collections.CollectionBase

    Public Sub Adicionar(ByVal item As funcionario)
        innerlist.add(item)
    End Sub

    Public Function item(ByVal index As Integer) As funcionario
        Return (innerlist(index))
    End Function

    ...  

End Class

O problema de coleções assim é que para cada tipo de dados para o qual desejarmos ter uma coleção precisaremos codificar uma classe coleção diferente. Se tentarmos utilizar uma classe coleção única seremos obrigados a trocar a definição de tipo "funcionario" por Object.

A criação de uma coleção de Objects nos traz dois problemas :

  • A coleção aceitará qualquer coisa, um objeto de tipo indesejado pode vir a ser inserido na coleção, causando erro na aplicação.
  • Se utilizarmos a coleção de Objects para armazenar valores inteiros então estaremos armazenando inteiros em variáveis object. Inteiros são dados do tipo Value Type, Object é uma informação do tipo reference type. Esse tipo de atribuição causa um processo que é chamado de boxing e unboxing e gera perda de performance.

Então como solucionar esse impasse ? A solução é exatamente o uso de Generics. Através da síntaxe dos Generics é possível solucionarmos o problema, criando uma coleção que funcione para qualquer tipo de dados. Veja como fica :

Public Class ColecaoQualquerCoisa(Of tipo)
    Inherits system.Collections.CollectionBase

    Public Sub Adicionar(ByVal item As tipo)
        innerlist.add(item)
    End Sub

    Public Function item(ByVal index As Integer) As tipo
        Return (innerlist(index))
    End Function

    ...  

End Class

Neste trecho de código "tipo" vira uma incógnita que só é definida no momento de uso desta coleção. Veja como fica o código para utilizar esta coleção :

        Dim col As New ColecaoQualquerCoisa(Of funcionario)
        Dim col2 As New ColecaoQualquerCoisa(Of Integer)

A variável col neste exemplo passa a ser uma coleção de funcionários, fortemente tipada, nenhum outro tipo de dados poderá ser inserido na coleção. Já a variável col2 passa a ser uma coleção de inteiros, sem causar boxing e unboxing. Tudo resolvido com a definição da classe colecaoqualquercoisa uma única vez, sem a necessidade de recodificação.

Os generics não precisam ser utilizados apenas na criação de classes. Um outro bom exemplo do uso de Generics é justamente o código para exibição dos dados da coleção. Neste caso o código pode ser uma simples sub, veja como fica :

     Sub Exibir(Of tipo)(ByVal col As CollectionBase)
        Dim item As tipo

        For Each item In col
            msgbox(item.tostring)
        Next
    End Sub

Para utilizar o método :

Exibir(Of funcionario)(col)

Overload de operadores

Quando falo de operadores estou me referindo realmente aos operadores matématicos, +,-,/,*,etc...

Além destes o ctype também é considerado um operador.

Quando aplicamos estes operadores sobre números, por exemplo, temos o resultado esperado. Mas o que ocorre se aplicamos esses operadores sobre classes personalizadas ?

É justamente ai que entra o overloads de operadores. Através deste novo recurso da linguagem podemos definir qual o efeito que um determinado operador terá sobre uma classe. Podemos então fazer operações matemáticas com as classes. Por exemplo, para adicionar uma classe em uma coleção podemos simplesmente utilizar o operador de adição (+) desde que a coleção tenha definido este operador.

Vejamos um exemplo com o ctype. Veja o trecho abaixo :

        Dim f As New funcionario
 ...
         MsgBox(f)

Normalmente teremos um erro na linha do msgbox, acusando não ser possível converter a classe para string. Digamos que utilizemos o ctype :

        MsgBox(CType(f, Decimal))

Não melhorou muito, pois ainda assim teremos a mensagem de que não é possível converter funcionário para decimal.

Porém podemos, dentro da classe funcionário, definir a ação que será feita pelo operador ctype e desta forma fazer com que esta instrução passe a ser válida. Veja como fica um pequeno exemplo :

Class funcionario

...

    Public Shared Narrowing Operator CType(ByVal obj As funcionario) As Decimal
        Return (obj.salliq)
    End Operator

...

End Class

Com este código estamos dizendo que sempre que houver uma tentativa de fazer o ctype de funcionário para decimal deve ser devolvido o salário líquido do funcionário.

Podemos fazer overloads dos outros operadores e desta forma poder manipular as classes utilizando os operadores matemáticos.

 

Dennes Torres
MCAD,MCSD,MCSE,MCDBA

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?