Resumo: Visão geral de como a função My expõe a funcionalidade do .NET Framework, incluindo classes disponíveis, classes geradas dinamicamente e threading.
Observação: este artigo e o código de exemplo baseiam-se na versão de pré-lançamento do Microsoft Visual Studio 2005 (anteriormente codinome "Whidbey"). Todas as informações aqui contidas estão sujeitas a alterações. O projeto de exemplo requer Visual Studio2005Beta1 ou superior.
Introdução
My é um novo recurso do Visual Basic 2005 que coloca funcionalidades usadas com frequência ao seu alcance e reduz o número de linhas de código que você precisa escrever. Ele faz isso de maneira eficiente, confiável e segura para threads. Em um ambiente onde a produtividade do programador é particularmente importante, o My pode ajudá-lo a concluir seu trabalho com mais rapidez. Essa é a essência do Visual Basic.
O objetivo deste artigo é explorar como usar My para acessar funcionalidades e itens do .NET Framework em seu projeto.
Classes .NETFramework disponíveis em My
Como há tantas coisas envolvidas no .NET Framework, pode ser difícil encontrar a funcionalidade necessária. Para resolver esse problema, My fornece pontos de entrada para classes e funções do .NET Framework comumente usadas. My também expõe novas classes de alto nível do .NET Framework que agregam funcionalidades relacionadas em APIs baseadas em tarefas.
My expõe a funcionalidade retornando uma classe .NETFramework que é instanciada e pronta para uso, adiando chamadas para métodos .NETFramework e retornando classes geradas dinamicamente que podem ser usadas para acessar itens em seu projeto.
Diretamente público
Sempre que possível, My serve como mecanismo de descoberta para classes existentes no .NET Framework e expõe esses tipos diretamente. Consulte o seguinte exemplo My.application.Deployment:
PublicReadOnlyPRpertyDeployment()As_
System.Deployment.ApplicationDeployment
Pegar
Retornar_
System.Deployment.ApplicationDeployment.CurrentDeployment
FimObter
Propriedade Final
Outros exemplos de exposição direta incluem My.Computer.FileSystem.OpenTextFileReader() (que retorna System.IO.StreamReader), My.Application.OpenForms() (que retorna System.Windows.Forms.FormsCollection), My.User (que retorna System.Security.Principal.IPrincipal), etc.
Aparência
My também pode retornar novas classes que fornecem uma API baseada em tarefas para executar operações que antes eram difíceis de executar porque era difícil encontrar funcionalidade e/ou exigia que vários objetos funcionassem juntos.
Tarefas comuns que exigem o uso da API do .NET Framework de baixo nível ou que exigem várias linhas de código são bastante simplificadas. Consulte o exemplo de tarefa a seguir para determinar se uma conexão de rede está disponível:
ImportsSystem.Net.NetworkInformation
PublicReadOnlyPropertyIsAvailable()AsBoolean
Pegar
ForEachNetInterfaceAsNetworkInterfaceIn_
NetworkInterface.GetAllNetworkInterfaces()
IfNetInterface.Type<>InterfaceType.Loopback_
AndAlsoNetInterface.Type<>InterfaceType.Tunnel_
AndAlsoNetInterface.OperationalStatus=_
OperationalStatus.UpThen
ReturnTrue
FimSe
Próximo
RetornoFalso
FimObter
Propriedade Final
O código acima requer conhecimento detalhado de vários tipos no namespace System.Net.NetworkInformation. Usando o padrão de aparência, My.Computer.Network reduz esses tipos e seus relacionamentos a uma única linha de código: My.Computer.Network.IsAvailable().
As aparências também podem simplesmente reunir funcionalidades relacionadas que, de outra forma, seriam difíceis de encontrar. Por exemplo, My.Computer reúne propriedades de diferentes classes para fornecer o nome do computador e o acesso à tela:
PublicReadOnlyPropertyName()AsString
Pegar
ReturnSystem.Environment.MachineName
FimObter
Propriedade Final
PublicReadOnlyPropertyScreen()AsSystem.Windows.Forms.Screen
Pegar
ReturnSystem.Windows.Forms.Screen.PrimaryScreen
FimObter
Propriedade Final
Outros exemplos de classes em My que reúnem funcionalidades relacionadas de vários tipos do .NET Framework incluem My.Application, My.Computer, My.Computer.FileSystem, My.Computer.Info e My.Application.Info.
Classe proxy
A classe proxy é uma classe muito "fina" que encaminha todas as chamadas para o objeto base. Por exemplo, se você chamar My.Computer.Clipboard.GetText(), na verdade estará chamando o método da classe proxy ClipboardProxy.GetText(), definido da seguinte forma:
PublicFunctionGetText()AsString
ReturnClipboard.GetText()
Função Final
Por convenção, as classes proxy sempre possuem o sufixo Proxy. My usa proxies ao acessar a área de transferência, o sistema de arquivos e o registro porque as classes base expostas pelos proxies são compostas de métodos compartilhados que não são visíveis no IntelliSense. A classe Proxy não pode ser instanciada pelo usuário. Os testes de desempenho mostraram que não faz sentido encaminhar chamadas por meio de um proxy.
Classes geradas dinamicamente
Alinhado ao propósito de “colocar a funcionalidade ao seu alcance”, o My fornece acesso aos formulários, serviços Web, recursos e configurações definidas em seu projeto. Por exemplo, se o seu projeto contiver uma referência ao serviço da web MapDirections, você poderá usar o serviço da web imediatamente sem precisar saber como iniciar uma instância do proxy de serviço da web. Basta digitar o seguinte: My.WebServices.MapDirections.GetDirections(...)
Como é que isso funciona? As classes de fábrica são geradas por um compilador que retorna instâncias criadas lentamente sob demanda para os formulários, serviços da Web, configurações e recursos do seu projeto. A classe de fábrica é adaptada para retornar instâncias de maneira adequada ao tipo de projeto (exe/dll/web) no qual seu código está sendo executado. Consulte a seção "Threading" para obter mais detalhes.
Meus.Formulários
Como exemplo de classe gerada dinamicamente, considere My.Forms. Esta classe é fornecida a você e define métodos de fábrica para cada formulário do seu projeto. Ao acessar o Form através de My.Forms.Form1, o método de fábrica verifica se uma instância do Form1 já está aberta. Se uma instância já estiver aberta, essa instância será retornada. Caso contrário, uma instância do Form1 será criada e retornada. O código gerado para o projeto contendo Form1 é assim:
ClassMyForms
'Código em negrito gerado pelo compilador
Publicm_Form1AsForm1
PublicPropertyForm1()AsForm1
Pegar
m_Form1=Criar__Instância__(OfForm1)(m_Form1)
Retornom_Form1
FimObter
Definir(ByValValueAsForm1)
IfValueIsm_Form1
Retornar
FimSe
IfNotValueIsNothingThen
ThrowNewArgumentException(_
A propriedade só pode ser definida para nada.)
FimSe
Dispose__Instance__(OfForm1)(m_Form1)
FimSet
Propriedade Final
Fim da Classe
A função Create__Instance__() é responsável por criar instâncias do formulário sob demanda. Verifica se o formulário (armazenado em m_Form1) foi instanciado. Se o formulário já tiver sido instanciado, o formulário será retornado. Caso contrário, uma instância será criada e retornada. Create__Instance__() também captura tentativas de criação de formulário recursivo. Dispose__Instance__() é responsável por fechar o formulário.
My.Forms também fornece um método para reintroduzir uma instância padrão de um formulário, com o qual você pode estar familiarizado em versões anteriores do Visual Basic. As instâncias padrão tornam possível fazer referência a uma instância de um formulário sem primeiro criar explicitamente uma instância do formulário.
Por exemplo, no Visual Basic 6.0, você pode ter escrito Form1.Show() em vez disso:
DimForm1InstânciasForm1
Form1Instância = novoForm1
Form1Instance.Show()
Como o compilador do Visual Basic 2005 usa My.Forms para criar instâncias padrão, você pode simplesmente escrever Form1.Show().
Meus.WebServices
Uma das dificuldades que as pessoas encontram ao codificar serviços da Web é determinar em qual classe codificar. My.WebServices elimina esse processo de determinação e fornece instâncias de proxies de serviços da Web sob demanda.
My.WebServices é mais adequado para chamadas síncronas para serviços da Web. O padrão de código gerado para fornecer uma instância do proxy de serviço da Web é igual ao padrão de código mostrado para retornar uma instância do formulário.
Minhas.Configurações
Uma novidade no Visual Basic 2005 é o Designer de Configurações, que permite especificar configurações de aplicativo por aplicativo ou usuário. O designer cria uma classe que você pode usar para acessar suas configurações de maneira fortemente digitada. Você pode ver um exemplo da classe MySettings mostrando Todos os Arquivos no Solution Explorer e procurando o arquivo MySettings.vb no nó MySettings.Settings.
A seguir está um exemplo de uma propriedade gerada para gerenciar uma configuração de aplicativo chamada SampleUserSetting:
PartialNotInheritableClassMySettings
InheritsSystem.Configuration.ApplicationSettingsBase
<System.Diagnostics.DebuggerNonUserCode(),_
System.Configuration.UserScopedSettingAttribute(),_
System.Configuration.DefaultSettingValueAttribute(TryMe)>_
PublicPropertySampleUserSetting()AsString
Pegar
ReturnCType(Me(SampleUserSetting),String)
FimObter
Definir
Eu(SampleUserSetting)=valor
FimSet
Propriedade Final
Fim da Classe
As classes geradas fazem todo o trabalho pesado para você. Para acessar esta configuração, basta digitar:
My.Settings.SampleUserSetting
Meus.Recursos
Outro novo recurso do Visual Basic 2005 é o Resource Designer, que permite adicionar recursos ao seu aplicativo. O Resource Designer também cria um módulo que você pode usar para acessar recursos em seu aplicativo de maneira fortemente tipada. Por exemplo, se você adicionar um bitmap chamado Smiley ao seu projeto, poderá acessar o bitmap usando My.Resources.Smiley. Você pode ver um exemplo do módulo de recurso gerado exibindo Todos os Arquivos no Solution Explorer do projeto de exemplo e procurando o arquivo MyResources.vb no nó MyResources.resx.
Veja a seguir um exemplo de projeto de amostra gerado para retornar uma propriedade de fábrica para um recurso Smiley:
PublicReadOnlyPropertySmiley()AsSystem.Drawing.Bitmap
Pegar
ReturnCType(ResourceManager.GetObject(Smiley,_resCulture),_
Sistema.Desenho.Bitmap)
FimObter
Propriedade Final
O módulo de recursos fortemente digitado gerado lida com IDs de recursos que diferenciam maiúsculas de minúsculas, usa a classe System.Resources.ResourceManager para recuperar seus recursos e gerencia os detalhes relacionados à criação correta do ResourceManager para seu aplicativo.
Para acessar o mesmo bitmap Smiley no VisualBasic2002 ou VisualBasic2003, primeiro é necessário colocar o bitmap em um arquivo .resx, o que é difícil. Outra forma é colocá-lo no projeto como um recurso incorporado e você deve se lembrar de alterar a ação de construção na grade de propriedades do recurso que será o recurso incorporado. Desta forma, o código que você escreve deve ficar assim:
DimCurrentAssemblyAsReflection.Assembly=_
Reflection.Assembly.GetExecutingAssembly
DimBitMapStreamAsIO.Stream=_
CurrentAssembly.GetManifestResourceStream(_
WindowsApplication2.Smiley.bmp)
DimSmileyBitmapasDrawing.Bitmap=NewBitmap(BitMapStream)
Existem alguns detalhes importantes neste código que você precisa saber. Você precisa saber como obter o assembly em execução no momento e chamar GetManifestResourceStream() nele. Você deve se lembrar de qualificar nomes de recursos com o nome do namespace raiz. Você deve obter permissão de maiúsculas e minúsculas porque o nome passado para GetManifestResourceStream() diferencia maiúsculas de minúsculas. Você deve saber onde definir a classe de fluxo para poder capturar o valor de retorno de GetManifestResource no objeto de fluxo. Você deve saber como criar um bitmap a partir de um fluxo. Você pode ficar frustrado ao tentar determinar por que um BitMapStream sempre retorna Nothing devido a um dos problemas acima.
O Visual Basic 2005 resolve o primeiro problema fornecendo o ResourceEditor, que facilita a colocação de recursos novos ou existentes em arquivos .resx. Esses recursos podem ser facilmente acessados usando My. Tudo que você precisa fazer é escrever o seguinte:
DimSmileyBitmapasDrawing.Bitmap=My.Resources.Smiley
Rosqueamento
As instâncias de classe disponíveis em My são expostas de uma maneira que alivia problemas de threading, porque as instâncias de objetos My são fornecidas por thread. Ou seja, a instância de My.Computer retornada no thread 1 é diferente da instância de My.Computer retornada no thread 2. Isso significa que você não precisa escrever código de sincronização ao usar o objeto My.
Em uma aplicação web, a instância retornada de My é armazenada mediante solicitação.
resumo
Vimos como My expõe classes do .NET Framework e como classes geradas dinamicamente podem ser geradas para complementar My.
Por fim, My reduz o número de linhas de código que você precisa escrever e fornece acesso às funcionalidades comumente usadas. Ele faz isso de maneira eficiente, confiável e segura para threads. Em um ambiente onde a eficiência do trabalho do programador é particularmente importante, o My pode ajudá-lo a concluir seu trabalho de forma mais rápida e eficaz.
->