Otimizando o processo de criação de componentes para o COM+

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)

Veja neste artigo: Como otimizar o processo de criação de componentes para o COM+.

Artigo extraído do site: www.bufaloinfo.com.br

Autor: Dennes Torres

 

Quando a geração de componentes COM para o MTS passou a poder ser realiza pelo VB 5 o processo de geração de componentes COM não era simples : a cada vez que faziamos alguma alteração no código o componente precisava ser retirado do MTS e reinserido no MTS.

Até que no TechEd que ocorreu em São Paulo (não lembro exatamente o ano) um dos palestrantes contou ter identificado justamente esse problema e criou um AddIn que automaticamente, durante o processo de recompilação, atualizava o componente no MTS.

Esse AddIn se tornou muito importante no desenvolvimento em camadas, tanto que foi incorporado ao VB 6 e ao próprio MTS, já acompanhando sua instalação.

Agora que temos o VS.NET, temos também o mesmo problema de volta. O VS utiliza uma grande sequencia de passos para criarmos e disponibilizarmos componentes para o COM+ . Veja os passos desta sequencia :

- Criar uma chave de assinatura através da ferramenta SN
- Registrar o componente no COM+ através do RegSvcs
- Inserir o componente no GAC (Global Assembly Cache)

Quando o componente já foi compilado antes podemos evitar a criação da assinatura, mas teremos que retirar o componente do COM+ e do GAC. Tudo isso a cada alteração que estivermos fazendo, o que torna o processo de geração de componentes transacionais para o COM+ bem complexo.

É necessário então criarmos para o .NET algo que possa realizar a mesma tarefa que aquele AddIn do VB 5 e 6 realizava. Felizmente para isso poderemos utilizar recursos do próprio VS.

O menu Tools do VS tem uma área reservada para as external tools, ferramentas externas. O VS nos permite configurarmos novos itens de menu e é este recurso que nos permite adicionarmos estas ferramentas (SN, RegSVCS, GacUtil) nos menus do VS.

Para criarmos um novo item de menu devemos clicar em Tools->External Tools... e clicar no botão Add . Com isso abrem-se as caixas em branco para que possamos definir uma nova external tools. Vamos então partir para a configuração das ferramentas :

Título : Gerar Strong Name
Command : C:\Program Files\Microsoft Visual Studio .NET\FrameworkSDK\Bin\sn.exe
Arguments :
O SN ignora o parâmetro que vem em seguida, Initial Directory, por isso precisamos não apenas definir o nome do arquivo no qual será criada a chave mas também o caminho para isso. Veja :

-k $(TargetDir)..\..\bin\chave.snk

A variável TargetDir representa o diretório obj\debug, abaixo da raiz do projeto. Com a instrução acima estaremos criando a chave no diretório bin, abaixo da raiz do projeto.

Marcamos o Use Output Window para que o resultado seja visto na janela de OutPut.

Título : Registrar no COM+
Command : C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705\RegSvcs.exe
Arguments : $(TargetName)$(TargetExt)
Initial Directory : $(TargetDir)

Pelo fato de estarmos utilizando o TargetDir estaremos na verdade inserindo no COM+ o assembly que está abaixo de obj\debug

Título : Registrar no GAC
Command : C:\Program Files\Microsoft Visual Studio .NET\FrameworkSDK\Bin\gacutil.exe
Arguments : /i $(TargetName)$(TargetExt)
Initial Directory : $(TargetDir)

Título : Desregistrar do COM+
Command : C:\WINDOWS\Microsoft.NET\Framework\v1.0.3705\RegSvcs.exe
Arguments : -u $(TargetName)$(TargetExt)
Initial Directory : $(TargetDir)

Título : Desregistrar do GAC
Command : C:\Program Files\Microsoft Visual Studio .NET\FrameworkSDK\Bin\gacutil.exe
Arguments : /u $(TargetName)
Initial Directory : $(TargetDir)

image002.jpg

Com essas configurações passamos a poder rapidamente fazer a atualização de um componente no COM+ para podermos testa-lo através da aplicação client. Mas os mais exigentes devem estar dizendo : Mas ainda tem muito menu para clicar !

Para melhorar isso ainda mais podemos fazer uma gravação de macro no Visual Studio, gravando a sequencia de itens de menu que precisaremos utilizar.

Precisaremos gravar duas sequencias:

1a instalação do componente :

  • Criar a chave
  • Compilar
  • Registrar no COM+
  • Registrar no GAC

Reinstalação do componente :

  • Desregistrar do COM+
  • Desregistrar do GAC
  • ReCompilar
  • Registrar no COM+
  • Registrar no GAC

Eis como fica a primeira sequencia, já com o nome da sub trocado :

Sub PrimeiraCompilacao()
DTE.ExecuteCommand("Tools.ExternalCommand7")
DTE.ExecuteCommand("Build.RebuildSolution")
DTE.ExecuteCommand("Tools.ExternalCommand8")
DTE.ExecuteCommand("Tools.ExternalCommand9")
End

Observeque as external tools são acessadas numericamente, portanto não adianta copiar esse código para o seu VS, não há muitas chances de que ele funcione. Será necessário que você mesmo faça a gravação da macro.

Veja como fica a segunda sequencia :

Sub Recompilacao()
DTE.ExecuteCommand("Tools.ExternalCommand10")
DTE.ExecuteCommand("Tools.ExternalCommand11")
DTE.ExecuteCommand("Build.RebuildSolution")
DTE.ExecuteCommand("Tools.ExternalCommand8")
DTE.ExecuteCommand("Tools.ExternalCommand9")
End Sub

image004.jpg

Não dá para perceber muita diferença justamente pelo fato das external tools serem acessadas numericamente.

Depois de gravadas as macros devemos inserir essas macros nos menus ou toolbars de forma a podermos executa-las rapidamente. Para isso devemos utilizar o menu Tools->Customize.

Na janela que se abre devemos clicar na aba commands. Na listbox da esquerda selecionamos o item "Macros" e veremos uma lista das macros disponíveis na listbox da direita, incluindo as duas macros que gravamos. Poderemos então arrastar as macros de dentro da listbox para um dos menus ou uma das ToolBox, de forma a podermos utiliza-las facilmente.

image006.jpg

Depois de arrastarmos a macro para um dos menus ou toolbox podemos clicar com o botão direito sobre o novo item de menu ou novo botão na toolbox e utilizando as opções que serão exibidas configurar a forma como o item será exibido (imagem, descrição, etc.).

image008.jpg

Porém as macros infelizmente não melhoram muito o uso das external tools. Infelizmente a execução das external tools é assíncrona. Isso significa que a macro não irá esperar uma das external tools terminar sua execução antes de passar para a próxima. Consequentemente o funcionamento destas macros não é garantido, pode as vezes funcionar, as vezes não. Você pode até experimentar inserir um loop para realizar um delay entre as chamadas das external tools, fica a seu critério.

Outro problema que também precisa ser resolvido é a configuração do projeto. A configuração do projeto é demasiadamente complexa. Veja :

1) Cria-se uma Class Library
2) Elimina-se a Class1.VB
3) Insere-se um Imports para system.runtime.interopServices
4) Define-se uma interface
5) Define-se o interfacetype
6) Define-se o ClassInterface
7) Implementa-se a interface
8) No assemblyInfo faz-se o Imports do system.enterpriseServices
9) Configura-se no AssemblyInfo o ApplicationName
10) Configura-se no AssemblyInfo o AssemblyKeyFile
12) Configura-se no AssemblyInfo o ApplicationID
14) Insere-se um projeto client
15) Configura-se a solução para um duplo start
16) Configura-se o projeto da Class Library para iniciar o DLLHost

Esse conjunto de tarefas é complexo e trabalhoso. O ideal seria termos um modelo de projeto que ja venha com todas essas configurações. Pois o Visual Studio .NET nos permite criar um modelo de projeto assim.

O primeiro passo para criarmos um modelo de projeto assim é criarmos um projeto e configurarmos o projeto com todas essas características. Com o projeto criado poderemos transferi-lo para a pasta de templates do Visual Studio .NET

Devemos então localizar a pasta que contem nosso projeto e copia-la para a pasta onde encontram-se os templates (Building Blocks) do Visual Studio. A pasta é \program files\Visual Studio .NET\EnterpriseFrameWorks\Projects

Mas a cópia da pasta do projeto para a pasta Projects não é suficiente. Precisamos realizar configurações para determinar em que local da janela New Project o nosso template de projeto deverá aparecer. Para isso vamos primeiramente criar uma pasta abaixo da pasta ProxyProjects. O caminho completo da ProxyProjects é \program files\Visual Studio .NET\EnterpriseFrameWorks\ProxyProjects . Vamos criar uma pasta chamada User Projects .

Dentro da pasta User Projects vamos criar um arquivo texto e dar o nome de UserProjects.vsdir . Este arquivo irá apontar para o nosso Building Block. Vamos dentro deste arquivo inserir a seguinte linha :

..\..\Projects\PastadoProjeto\ArquivodoProjeto.vbproj|{AE77B8D0-6BDC-11d2-B354-0000F81F0C06}|OptionalProject|10|An example of a user-created optional language project|{FAE04EC1-301F-11d3-BF4B-00C04F79EFBC}|4547|0|Project

Claro que em PastadoProjeto e ArquivodoProjeto você irá alterar para os nomes dados ao projeto.

Feito isso o próximo passo é definirmos como (em que pasta) o nosso projeto irá aparecer. Para isso vamos criar dentro do diretório ProxyProjects um arquivo texto e dar-lhe o nome de UserProjects.vsdir . neste arquivo vamos inserir a seguinte linha :

UserComponents|{AE77B8D0-6BDC-11d2-B354-0000F81F0C06}|0|10

Feito isso já poderemos testar. Nosso projeto já estará aparecendo dentro do Visual Studio, nos polpando tempo de ficarmos definindo todas as características que desejamos.

Dennes Torres
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?