O Visual Basic fez no dia 20 de Maio, 20 anos de existência. Durante estes anos muitas coisas mudaram e muitas coisas certamente vão mudar, mas é uma linguagem de programação que não pode ficar indiferente a ninguém, pelo seu passado e também pelo seu presente.
VB (da versão 1 à 6), ASP Clássico, VBA, VBScript, eVB, VB.NET, ASP.NET, etc, são algumas das aplicações/áreas onde podemos encontrar e usar o Visual Basic, sendo por isso tão usado e popular.
Quero partilhar um post na Visual Basic Team, criado pelo Anthony D. Green (Program Manager - Visual Basic Compiler) que partilha algumas evoluções e links interessantes, como o anuncio da primeira versão do Visual Basic, disponível do youtube.
Twenty years ago, May 20th, 1991 at Windows World, in Atlanta, Microsoft founder Bill Gates demoed Visual Basic 1.0. Twenty years later, the 10th version of this latest in an unbroken line of Microsoft BASIC languages stretching back to Microsoft’s founding is still going strong. When you look back over the history of a tool that’s been around that long you start to see some familiar experiences from Wetware products (commonly called children :P ): The cute and cuddly days of its youth, in the 16-bit era; the awkward teen years and the transition to .NET; sibling rivalry with the new baby (C#); and finally getting those braces … er, underscores off :). And now, finally out of those turbulent teen years, a matured language looks to the future. Visual Basic has always had a personality for humanizing programming and with Async methods in vNext it continues that tradition.
You might ask after two-decades how VB can keep re-inventing itself to face modern and future challenges. The answer is quite literally that – re-inventing itself. OK, more accurately re-writing itself. The VB compiler is being re-written from the ground up in Visual Basic and its syntactic and semantic analysis services exposed through a managed API that exposes parse trees, expression binding, assembly production (and more) to enable a world of new scenarios including REPL, VB as a scripting language, and more. It’s all very exciting! As a VB user for … half my lifetime, now, it’s great to look back and be proud of where VB has been, happy with where it is, and especially excited about where it’s going!
I have many fond memories of Visual Basic and likewise great aspirations for its future and I know millions of customers out there have the same. Please, share your stories (and hopes), and join me in wishing our old :P friend, VB, a Happy 20th Birthday and many more! :D
Anthony D. Green
Program Manager
Visual Basic (code-name "Roslyn") Compiler
Fonte: http://blogs.msdn.com/b/vbteam/archive/2011/05/20/happy-20th-birthday-visual-basic.aspx
A Ciclo, Formação e Consultoria, está a organizar algumas acções de formação em VBA (Visual Basic for Applications), em Microsoft Excel, formações essas ministradas por mim.
Estão agendadas para breve duas acções distintas, para as quais tenho alguns vouchers de desconto para oferecer. As acções de formação são as seguintes:
C5004 – Introdução ao VBA
Destina-se a todos os que já trabalham frequentemente com folhas de cálculo de Excel e que pretendem utilizar ferramentas de programação para melhorar ainda mais o desempenho das suas folhas de cálculo, automatizar processos e cálculos através do recurso à programação em VBA.
Data: 23, 24, 25, 27 e 27 de Maio de 2011 (20 horas), no horário laboral, das 9:00 às 13:00.
C5014 – VBA Avançado
Destina-se a todos os que já trabalham frequentemente com VBA nas suas folhas de cálculo de Excel e que pretendem aprender as melhores práticas de desenvolvimento e performance, utilização de controlos COM, utilização de classes externas (VB.NET/C#), fazer a personalização da Ribbon, Add-Ins, Userforms, UDF, etc. .
Data: 9, 10, 16 e 18 de Maio de 2011 (16 horas), no horário pós-laboral, das 19:00 às 23:00.
Tenho 1 voucher de 50% de desconto e 3 vouchers de 10% de desconto, para cada curso, para as primeiras pessoas que me enviarem um email (vbtuga @ gmail . com) com o código do curso pretendido e os seus dados.
Existem três tipos de abordagens quando estamos a utilizar Entity Framework 4.0: database-first onde são criadas as nossas entidades (classes) usando uma base de dados já existente; model-first onde é criado o nosso modelo conceptual e, com base nele, é gerado um script para a criação da base de dados; e code-first onde é utilizado POCO (Plain Old Code CRL) para criação manual de toda a lógica de entidades e ligação, não perdendo no entanto, todas as vantagens da utilização do Entity Framework.
Na edição da Revista PROGRAMAR nº 26, de Dezembro de 2010, abordei a utilização do modelo database-first, mostrando como criar as entidades e como efectuar algumas operações CRUD (acrónico para Create, Read, Updade e Delete).
Neste artigo irei abordar de uma forma geral como utilizar as restantes abordagens: model-first e code-first.
Esta abordagem permite-nos criar o nosso modelo conceptual, usando o Visual Studio, e depois, com base neste, criar a base de dados. Após a criação do modelo é criada a DDL (Data Definition Language), que será guardado num ficheiro *.sql e que nos permite então criar a base de dados.
Existem algumas vantagens desta abordagem pois é uma forma de trabalhar onde temos o nosso modelo e não nos precisamos de preocupar com a base de dados ou como esta irá ser construída. Não necessitamos também de ter conhecimentos muito específicos de bases de dados (como criar tabelas, relações, etc.), sendo tudo feito no Visual Studio de uma forma simplificada. Além disso, ficamos com o DDL que nos permite criar a base de dados em qualquer altura (por exemplo após a instalação da aplicação).
Neste exemplo será criada uma Class Library, permitindo assim isolar a lógica de acesso a dados e, caso seja necessário, reutilizar em diferentes projectos.
Para a criação do nosso modelo, numa abordagem model-first, criamos um novo projecto no Visual Studio 2010 definindo como Framework a 4.0, e com o nome “RevistaClassLibrary”.
NOTA: Após o projecto criado podemos apagar a classe que aparece por defeito (Class1 .vb) pois não será necessária.
Adicionamos um novo item, recorrendo aos templates no separador Data - ADO.NET Entity Data Model. Esta opção, que iremos definir com o nome RevistaModel.edmx, irá criar um ficheiro *.edmx que irá representar o nosso modelo.
Este *.edmx é um ficheiro XML que define o modelo conceptual, o modelo de dados e as relações entre as diferentes entidades. Na seguinte opção, podemos escolher se queremos gerar um modelo de uma base de dados, como foi abordado no artigo anterior na Revista PROGRAMAR edição 26, ou criar um modelo vazio. Iremos escolher a segunda opção – Empty model.
Com o nosso documento criado, ainda vazio, existem duas ferramentas importantes para o desenvolvimento do modelo: a Toolbox, que tem agora objectos específicos para o Entity Framework e o Model Browser que permite explorar o nosso modelo. Existem duas formas de criar o modelo: através da Toolbox, já referida anteriormente, ou clicando com o botão direito do rato sobre a janela aberta. Esta segunda opção é mais simples de utilizar.
Ainda antes de iniciarmos a construção do nosso modelo conceptual, existe uma opção interessante, se olharmos para a janela das propriedades: Pluralize New Objects. Esta opção, caso esteja definida como verdadeira (True), irá automaticamente tentar pluralizar os nomes das entidades. Infelizmente não funciona na versão Portuguesa, mas se utilizarmos nomes em Inglês, é muito interessante.
Para este exemplo vamos então criar um modelo muito simplificado que permita representar as edições da revista PROGRAMAR. Vamos criar duas entidades que vão representar os artigos e os seus autores.
Por defeito, quando criamos uma nova entidade, ele inclui a criação de um identificador (chave primária), que podemos, caso não seja necessário, retirar. Não define também nenhuma herança, podendo esta ser indicada no “Base Type”, ou seja, podemos definir heranças entre entidades, seleccionado a entidade correspondente. Adicionando algumas propriedades, e definindo os tipos de dados correctos (ex. DataNascimento = DateTime ou Edicao = Int32), rapidamente construímos os modelos para representar as edições da revista.
De notar que por defeito, quando é adicionada uma nova propriedade à entidade, o tipo de dados está definido como String, com um tamanho de armazenamento máximo para este tipo de dados (2^3-1) - nvarchar(max). Podemos e devemos alterar, caso seja necessário, assim como explorar e ajustar as restantes propriedades, como por exemplo, o tamanho máximo para uma String (Max Lenght), qual o valor por defeito (DefaultValue), se permite valores nulos (Nullable), etc.
E já estão então criadas as duas entidades e neste momento só nos falta definir a relação entre ambas. Como um artigo pode ter vários autores e um autor pode ter vários artigos, necessitamos de criar uma relação muitos para muitos (many-to-many).
Ao adicionarmos a relação entre as entidades, usando a opção Association, é criado um novo campo no final, designado por Navigation Property, que irá permitir a navegação entre as entidades. Podemos alterar o nome da propriedade de navegação (caso seja necessário).
E já está! Este foi o último passo para criar o modelo conceptual e é agora altura de gerar a base de dados. Para o fazer é só necessário clicar com o botão direito do rato sobre o editor e seleccionar a opção “Generate Database from Model”.
Irá então aparecer um wizard que nos permite seleccionar uma ligação já existente ou criar uma nova.
Seleccionada a ligação que pretendemos, irá ser gerado um script DDL que permitirá, após execução, criar uma base de dados em SQL Server 2005, 2008 e Azure.
Reparem que apenas criamos duas entidades (autores e artigos), mas como definimos uma relação muitos para muitos (many-to-many), é necessário utilizar uma tabela auxiliar. O EF fez isso por nós e no SQL ficamos então com três tabelas, como se pode ver na seguinte imagem:
Se no Solution Explorer escolhermos a opção “Show All Files”, podemos ver que o nosso modelo (*.edmx) tem um ficheiro com a extensão *.vb (neste caso RevistaModel.Designer.vb) . Neste ficheiro podemos ver e o código que está por detrás do nosso modelo conceptual, e efectuar eventualmente, algumas alterações.
Ao adicionarmos um novo projecto a esta solução (*.sln), que irá representar a camada de apresentação (Presentation Tier), ou usando externamente, é necessário adicionar referências à classe que criamos (separador Project) e a System.Data.Entity (separador .NET). É necessário também copiar a Connection String, que se encontra no ficheiro de configuração (app.config ou web.config), uma vez que esta foi definida na Class Library, no momento de ligação à base de dados.
<connectionStrings> <add name="RevistaModelContainer" connectionString="
metadata=res://*/RevistaModel.csdl|res://*/RevistaModel.ssdl|
res://*/RevistaModel.msl; provider=System.Data.SqlClient;
provider connection string=" Data Source=.;Initial Catalog=master;Integrated Security=True; MultipleActiveResultSets=True" "providerName="System.Data.EntityClient" />
Connection String tem um conjunto de metadata que indica a localização do ficheiro de CSDL (Conceptual Schema Definition Language), do SSDL (Store Schema Definition Language) e do MSL (Mapping Schema Language). O asterisco (*) indica que estes ficaram embebidos no ficheiro binário, podendo isto ser alterado, indicando nas propriedades do modelo conceptual, que o Metadata Artifact Processing não esta Embed in Output Assembly mas sim Copy to Output Directory. Indica depois a ligação propriamente dita à base de dados.
Esta é outra abordagem que podemos utilizar em Entity Framework, além das já referidas neste artigo (model-first) e no artigo da edição 26 da revista PROGRAMAR (database-first).
Uma das vantagens do code-first (ou como é também designado code-only), utilizando POCO (Plain Old CLR objects ), é que não ficamos “presos” ao Entity Framework, pois todas as classes geradas automaticamente herdam da classe EntityObject. Além disso utilizamos as classes que queremos, com muito menos código (um exemplo mesmo pequeno como este tem mais de 300 linhas de código), o torna a manutenção da aplicação muito mais simples.
Para usar esta abordagem, onde somos nós que desenhamos as classes que vão representar as entidades, podemos seleccionar o nosso modelo conceptual (*.edmx) e na janela de propriedades, na opção “Code Generation Strategy”, que está definida para Default, seleccionamos None. Isto fará com que o código gerado automaticamente seja apagado, possibilitando desta forma o desenvolvimento personalizado.
Para representar o modelo conceptual mostrando anteriormente, e tendo em conta que este é um exemplo muito simples (para efeitos de demonstração apenas), necessitamos apenas de três classes: Artigo, Autor e RevistaModelContainer.
As duas primeiras classes ( Artigo e Autor), vão representar as duas entidades e definem as propriedades da classe e a associação entre ambas (usando uma ICollection). Podemos ter mais propriedades e mais métodos nas classes, mas para que isto funcione, temos de ter pelo menos as que estão definidas no modelo.
Imports System.Collections
Imports System.Data.Objects
Public Class Artigo
Public Property Id As Integer
Public Property Titulo As String
Public Property Texto As String
Public Property Edicao As Integer
' Overridable para permitir o LazyLoading
Public Overridable Property Autores() As ICollection(Of Autor)
Sub New()
Autores = New List(Of Autor)
End Sub
End Class
Public Class Autor
Public Property Id As Integer
Public Property Nome As String
Public Property DataNascimento As DateTime
' Overridable para permitir o LazyLoading
Public Overridable Property Artigos() As ICollection(Of Artigo)
Sub New()
Artigos = New List(Of Artigo)
End Sub
End Class
IMPORTANTE: A declaração de variáveis em Visual Basic não é, como sabem, case sensitive. No entanto, na declaração das propriedades das entidades (classes) é obrigatório que se declarem de acordo com o modelo (*.edmx), ou seja, há distinção entre maiúsculas e minúsculas.
A terceira classe é onde se define o nosso Container, que herdas do ObjectContext, ou seja, é onde criamos a ligação entre o Entity Framework e as nossas classes anteriores. O ObjectSet é novo na versão 4.0 do Entity Framework e permite-nos trabalhar os dados como colecções, permitindo também executar queries.
Public Class RevistaModelContainer
Inherits ObjectContext
Sub New()
' Indica a ConnectionString (ver em app.config) e nome do Container
MyBase.New("name=RevistaModelContainer", "RevistaModelContainer")
' Cria as instancias dos ObjectSets
_Artigos = MyBase.CreateObjectSet(Of Artigo)("Artigos")
_Autores = MyBase.CreateObjectSet(Of Autor)("Autores")
' Define que o LazyLoading está
' activo (por defeito não está)
MyBase.ContextOptions.LazyLoadingEnabled = True
End Sub
Private _Artigos As ObjectSet(Of Artigo)
Public ReadOnly Property Artigos() As ObjectSet(Of Artigo)
Get
Return _Artigos
End Get
End Property
Private _Autores As ObjectSet(Of Autor)
Public ReadOnly Property Autores() As ObjectSet(Of Autor)
Get
Return _Autores
End Get
End Property
End Class
Como é possível ver neste código, habilitamos a opção LazyLoadingEnable do ObjectContext, colocando-a a True. O Lazy Loading permite que as entidades relacionadas sejam automaticamente carregadas da fonte de dados quando acedemos às propriedades de navegação (neste caso Autores e Artigos).
E é tudo! Com poucas linhas de código criamos as nossas classes, que definem as nossas entidades, e criamos o nosso Container que permite interligar as classes com o Entity Framework.
Mas este é apenas um exemplo bastante simples e caso usássemos um modelo complexo, com inúmeras entidades e associações, era muito trabalhoso criar todas estas classes POCO.
Por isso o Entity Framework permite a utilização/criação de templates que geram o código por nós. São designados por T4 (Text Template Transformation Toolkit) Text Templates e são ficheiros de texto com uma extensão *.tt . Existe um template para a criação de classes POCO. Não está disponível nos templates do Visual Studio 201 0, mas se abrirmos o modelo conceptual e seleccionarmos “Add Code Generation Item”, podemos pesquisar no Online Templates e instalar.
Após a rápida instalação, podemos então seleccionar ADO.NET POCO Entity Generator.
Isto irá adicionar dois ficheiros *.tt ao projecto: POCOModel.tt e POCOModel.Context.tt. O POCOModel tem as classes que representam as entidades e o POCOModel.Context tem as classe de contexto.
NOTA: Ao adicionarmos os templates ao projecto, todo o código de Entity Framework será apagado. Desta forma, e muito rapidamente, criamos as nossas classes POCO usando estes templates.
Como foi possível ver ao longo deste artigo, e do artigo da edição nº 26 da revista PROGRAMAR, existem diferentes abordagens para a utilização do Entity Framework 4.0, permitindo criar um modelo relacional de uma base de dados, criar um modelo e com base neste criar a base de dados ou criando as nossas classes (entidades) usando POCO, ficando desta forma independentes e com a possibilidade de uma maior personalização de toda a lógica. A existência de templates permite simplificar o processo de criação de classes POCO e inclusive criar os nossos próprios templates.
No momento da criação deste artigo está já disponível o Entity Framework 4.1 Release Candidate que tem como principal novidade a DbContext API, que é uma abstracão simples do ObjectContex e que pode ser utilizada em qualquer abordagem (Database-First, Model-First e Code-First). Existe também algumas alterações na abordagem Code-First.
ADO.NET team blog
http://blogs.msdn.com/b/adonet/
Beginner's Guide to the ADO.NET Entity Framework
http://msdn.microsoft.com/en-us/data/ee712907
EF 4.1 Release Candidate Available
http://blogs.msdn.com/b/adonet/archive/2011/03/15/ef-4-1-release-candidate-available.aspx
EF 4.1 Model & Database First Walkthrough
http://blogs.msdn.com/b/adonet/archive/2011/03/15/ef-4-1-model-amp-database-first-walkthrough.aspx
EF 4.1 Code First Walkthrough
http://blogs.msdn.com/b/adonet/archive/2011/03/15/ef-4-1-code-first-walkthrough.aspx
 |
Este artigo está disponível na revista PROGRAMAR Nº 28 de Abril de 2011, entre muitos outros artigos de programação! |
