COMO: Usar flexível eventos do Visual Studio .NET

Traduções deste artigo Traduções deste artigo
ID do artigo: 318185 - Exibir os produtos aos quais esse artigo se aplica.
Este artigo foi arquivado. É oferecido "como está" e não será mais atualizado.
Expandir tudo | Recolher tudo

Neste artigo

Sumário

Use este guia passo a passo para criar um assembly .NET contendo um editor, um assinante e uma interface para manipular eventos menos rígidos no Microsoft COM +.

Requisitos

A lista a seguir descreve o hardware recomendado, software, infra-estrutura de rede e service packs que você precisa:
  • Microsoft Windows 2000 Professional, Microsoft Windows 2000 Server, Microsoft Windows XP Professional ou Microsoft Windows XP Server.
  • Microsoft .NET framework.
  • Microsoft Visual Studio .NET.
  • Microsoft Visual translation from VPE for Csharp .NET.
  • Microsoft COM +.
Este artigo pressupõe que você esteja familiarizado com os seguintes tópicos:
  • COM e Enterprise Services.
  • Estendendo metadados usando atributos.

Criar um assembly .NET que eventos menos rígida usa

O procedimento a seguir cria um assembly .NET contendo um editor, um assinante e uma interface que alças flexível eventos em serviços COM +:
  1. Clique em Iniciar , aponte para programas , aponte para Microsoft Visual Studio .NET e, em seguida, clique em Microsoft Visual Studio .NET .
  2. Clique em New Project .
  3. Em Project Types , clique em projetos translation from VPE for Csharp Visual .
  4. Em modelos , selecione Windows Application .
  5. Na caixa nome , digite HowToLCE e, em seguida, clique em OK .

    Agora você tem uma solução que contém o shell de um aplicativo Windows Forms.
  6. Crie uma biblioteca de classes que contém código para o publisher, o assinante e a interface que é compartilhada por ambos. No menu arquivo , aponte para Add Project e, em seguida, clique em New Project .
  7. Em Project Types , clique em projetos translation from VPE for Csharp Visual .
  8. Em modelos , clique em Class Library .
  9. Na caixa nome , digite ClassLibLCE e, em seguida, clique em OK .
  10. No Solution Explorer, em ClassLibLCE , clique com o botão direito do mouse em References e, em seguida, clique em Add Reference .
  11. Na guia .NET , em referências , clique em System.EnterpriseServices e em seguida, clique em Selecionar . Clique em OK .
  12. Adicione as seguintes diretivas usando na parte superior do arquivo Class1.cs para classes de acesso nesses namespaces:
    using System.EnterpriseServices;
    using System.Diagnostics;
    						
    ao compilar o componente de Biblioteca de classes , torna-se um assembly .NET. Após você registrá-lo, você pode executá-lo em serviços COM + porque o Editor e assinantes derivam EnterpriseServices.ServicedComponents() .
  13. Declare a interface que compartilharão essas duas classes. No arquivo Class1.cs, adicione o código a seguir após pública classe Class1 :
    public interface IEvSink
    {
    	void OnEvent1();
    	void OnEvent2();
    }
    					
  14. Substituir pública classe Class1 com o seguinte código para a classe Publisher:
    [EventClass]
    public class MyPublisher : ServicedComponent, IEvSink
    {
    	public MyPublisher()
    	{
    	// 
    	// TODO: Add constructor logic here.
    	// 
    	}
    	public void OnEvent1()
    	{}	
    	public void OnEvent2()
    	{}
    	}
    						
    aviso classe anterior está decorada com o atributo [EventClass]. Esse atributo é crítico. Ele informa ao serviços COM + que essa classe formulários a conexão entre o Editor e seu subscriber(s). Quando você trabalhou com o código neste artigo, observe que há não chamadas diretas para a classe MyPublisher. Em outras palavras, a interação entre o publisher e o assinante é manipulada por serviços COM + pela classe com o atributo [EventClass]. Portanto, o publisher não tem qualquer conhecimento direto do subscriber(s). Qualquer assinante registrado com serviços COM + para este aplicativo que usa a interface IEvSink pode receber eventos do Editor.
  15. É o bit final do código necessário na biblioteca de classes para o assinante. Essa classe manipula eventos acionados pelo editor. Nesse caso, você fizer uma entrada simples no log de eventos para mostrar que o assinante é notificado quando é feita uma chamada para a interface publicada. Adicione o seguinte código após a classe MyPublisher :
    public class MySubscriber : ServicedComponent, IEvSink
    {
    	EventLog ev = new EventLog("Application");
    
    	public void OnEvent1()
    	{
    		ev.Source = "ClassLibLCE";
    		ev.WriteEntry("OnEvent1 Fired");
    	}
    
    	public void OnEvent2()
    	{
    		ev.Source = "ClassLibLCE";
    		ev.WriteEntry("OnEvent2 Fired");
    	}
    }
    					
  16. Para usar o assembly compilado da biblioteca de classe, atribua ele um nome forte. Para gerar esse par de chaves criptográfica, use a ferramenta SN (sn.exe). Ele está localizado na pasta \bin em que a documentação do Kit (SDK) do desenvolvedor .NET Framework Software está instalada. A ferramenta SN é muito fácil de usar. A instrução de linha de comando usa a seguinte sintaxe:
    sn -k "C:\%DirectoryToPlaceKey%\%KeyName%.snk"
  17. Execute este comando no prompt de comando Visual Studio. NET. Clique em Iniciar , aponte para programas , aponte para Microsoft Visual Studio. NET , aponte para Visual Studio .NET Tools e, em seguida, clique em Visual Studio .NET Command Prompt . No prompt de comando, digite o seguinte:
    sn -k "C:\ClassLibLCE\key.snk"
    Se seu projeto Class Library não estiver nesse caminho, altere o caminho para a raiz da pasta de projeto de seu projeto Class Library.

    Uma chave é gerada. Para verificar isso, no Solution Explorer, selecione ClassLibLCE e, em seguida, clique no botão Mostrar todos os arquivos na barra de ferramentas Solution Explorer .

    Observe o item key.snk ClassLibLCE.
  18. Como essa chave ainda não estiver associada com o assembly de biblioteca de classes, crie essa associação. No Solution Explorer, em ClassLibLCE , clique duas vezes em AssemblyInfo.cs . Na AssemblyKeyFile , digite o seguinte entre as aspas existentes:
    "..\\..\\key.snk"
  19. Conclua o código para a solução inteira por cabeamento de um formulário do Windows à biblioteca de classes. Lembre-se que este formulário é apenas para fins de demonstração. Basicamente, ele serve como um "conjunto de teste". Adicione as referências apropriadas.
    1. No Solution Explorer, em HowToLCE , clique com o botão direito do mouse em References e clique em Add Reference no menu de atalho.
    2. Na guia .NET , clique em System.EnterpriseServices .
    3. Na guia projetos , clique em ClassLibLCE .
    4. Clique em Selecionar .
    5. Clique em OK .

      Observe os itens de System.EnterpriseServices e ClassLibLCE listados em referências .
  20. No Editor do código, clique em guia de Form1.cs [Design] clicar duas vezes em qualquer lugar no formulário para criar um manipulador de eventos Form1_Load . Para este manipulador de eventos adicione o seguinte código.

    Observe que há duas seções. A primeira é somente para o propósito de registrar a biblioteca de classes. Ele é usado somente uma vez. O segundo dispara os eventos do publisher.
    // Section #1
    // Register Class Library as a COM+ application.
        ClassLibLCE.MySubscriber l = new
        ClassLibLCE.MySubscriber ();
    
    // Section #2
    //  Call Events on Publisher
    //  ClassLibLCE.MyPublisher l = new ClassLibLCE.MyPublisher();
    //  l.OnEvent1();
    //  l.OnEvent2();
    					
  21. Pressione F5 para executar o aplicativo e registrar a biblioteca de classes.

    Isso torna o assinante acessível a, mas ainda não registrado com o, os serviços COM +. Depois que o formulário é carregado, fechá-lo. Isso é o método mais simples de registrar um assembly .NET para que ele pode tirar proveito de serviços COM +. No entanto, para registrar dessa maneira você deve fazer logon no computador local com direitos administrativos. Se os usuários que utilizam seu aplicativo não tem direitos administrativos para seu computador local, você pode registrar um assembly usando o utilitário regasm.exe para eles quando você implanta o aplicativo.
  22. Execute o snap-in Serviços de componentes.

    Você não pode configurar os assinantes usando atributos no .NET versão 1.0. Mas, você pode fazer isso manualmente, executando o snap-em serviços de componente: abrir Painel de controle , clique duas vezes em Ferramentas administrativas e clique duas vezes Serviços de componentes .

    Observação : se desejar, você pode escrever código para automatizar as etapas a seguir usando a biblioteca COM + 1.0 Admin. Para obter informações adicionais, exibir o conteúdo de biblioteca no Pesquisador de objetos.
  23. Expanda Serviços de componentes . Expanda computadores . Expanda Meu computador . Expanda aplicativos COM + . Expanda ClassLibLCE . Expanda componentes . Expanda ClassLibLCE.MySubscriber .
  24. Clique com o botão direito na pasta de inscrições , aponte para novo e, em seguida, clique em assinatura .
  25. No COM + Assistente de inscrição novo, clique em Avançar . Selecione a opção de inscrever-se a interface IEvSink . Clique em Avançar .
  26. Na página Selecionar classe de evento , clique em ClassLibLCE.MyPublisher . (Isso é a classe foi decorada com o atributo [EventClass].) Clique em Avançar .
  27. Digite o nome que você deseja usar e clique para selecionar a caixa de seleção ativar esta inscrição imediatamente . Clique em Avançar . Clique em Concluir .

Código para o arquivo Class1.cs

using System;
using System.EnterpriseServices;
using System.Diagnostics;

namespace ClassLibLCE
{
       /// <summary>
       /// Summary description for Class1.
       /// </summary>
       [EventClass]
       public class MyPublisher : ServicedComponent, IEvSink
       {
	     public MyPublisher()
	     {
	     // 
	     // TODO: Add constructor logic here.
	     // 
	     }

	     public void OnEvent1()
	     {}	

	     public void OnEvent2()
	     {}
	     }

	     public class MySubscriber : ServicedComponent, IEvSink
	     {
		EventLog ev = new EventLog("Application");

		public void OnEvent1()
		{
			ev.Source = "ClassLibLCE";
			ev.WriteEntry("OnEvent1 Fired");
		}

		public void OnEvent2()
		{
			ev.Source = "ClassLibLCE";
			ev.WriteEntry("OnEvent2 Fired");
		}
	}

	public interface IEvSink
	{
		void OnEvent1();
		void OnEvent2();
	}
}
				

Código para o arquivo AssemblyInfo.cs

using System.Reflection;
using System.Runtime.CompilerServices;

// 
// General information about an assembly is controlled through the 
// following set of attributes. Change these attribute values to modify
// the information associated with an assembly.
// 
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]		

// 
// Version information for an assembly includes the following four 
// values:
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
// 
// You can specify all the values or you can use the default Revision and 
// Build Numbers by using the '*', similar to this:

[assembly: AssemblyVersion("1.0.*")]

// 
// To sign your assembly, specify a key to use. For more 
// information about assembly signing, see the Microsoft .NET Framework 
// documentation.
// 
// Use the following attributes to control which key is used for signing. 
// 
// NOTES: 
//   (*) If no key is specified, the assembly is not signed.
//   (*) KeyName refers to a key that is installed in the Crypto Service
//       Provider (CSP) on your computer. KeyFile refers to a file that 
//       contains a key.
//   (*) If the KeyFile and the KeyName values are both specified, the 
//       following processing occurs:
//       (1) If the KeyName is found in the CSP, that key is used.
//       (2) If the KeyName does not exist and the KeyFile does exist, the 
//           key in the KeyFile is installed into the CSP and used.
//   (*) To create a KeyFile, you can use the Sn.exe (Strong Name) 
//       tool. When specifying the KeyFile, the location of the KeyFile 
//       must be relative to the project output folder which is
//       %Project Directory%\obj\<configuration>. For example, if your 
//       KeyFile is located in the project folder, specify the 
//       AssemblyKeyFile attribute as 
//          [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
//   (*) Delay Signing is an advanced option. For more information, see the 
//       Microsoft .NET Framework documentation.
// 
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("..\\..\\key.snk")]
[assembly: AssemblyKeyName("")]
				

Código para o arquivo Form1.cs

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace HowToLCE
{
	/// <summary>
	/// Summary description for Form1.
	/// </summary>
	public class Form1 : System.Windows.Forms.Form
	{
		/// <summary>
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.Container components = null;

		public Form1()
		{
			// 
			// Required for Windows Form Designer support.
			// 
			InitializeComponent();

			// 
			// TODO: Add any constructor code after the
			// InitializeComponent call.
			// 
		}

		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
				if (components != null) 
				{
					components.Dispose();
				}
			}
			base.Dispose( disposing );
		}

		#region Windows Form Designer generated code
		/// <summary>
		/// Required method for Designer support; do not modify
		/// the contents of this method with the Code Editor.
		/// </summary>
		private void InitializeComponent()
		{
			// 
			// Form1
			// 
			this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
			this.ClientSize = new System.Drawing.Size(292, 266);
			this.Name = "Form1";
			this.Text = "Form1";
			this.Load += new System.EventHandler(this.Form1_Load);

		}
		#endregion

		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			Application.Run(new Form1());
		}

		private void Form1_Load(object sender, System.EventArgs e)
		{
			//Section #1
			// Register Class Library as a COM+ application.
//			ClassLibLCE.MySubscriber l = new ClassLibLCE.MySubscriber();

			//Section #2
			// Call Events on Publisher.
				ClassLibLCE.MySubscriber l = new ClassLibLCE.MySubscriber();
						l.OnEvent1();
						l.OnEvent2();
		}
	}
}
				

Verifique se o Works

  1. Na janela Code Editor, comente o código na seção 1 do arquivo Form1.cs e descomente o código na seção 2.
  2. Execute somente o arquivo executável para o projeto HowToLCE. Para fazer isso, clique em Configuration Manager no menu Build . Desmarque a caixa de seleção criar ClassLibLCE . Clique em Fechar .
  3. Pressione F5 para executar o aplicativo no modo de depuração.
  4. Quando o formulário é carregado, feche-o.
  5. Pressione CTRL + ALT + S para iniciar Server Explorer. Expanda Servers . Expanda o computer name. Expanda Logs de eventos . Expanda o aplicativo . Expanda ClassLibLCE .

    Observe as duas entradas de log de eventos.

Solução de problemas

  1. Atualize o log de eventos para ver as entradas no Server Explorer.
  2. Se você fizer alterações à biblioteca de classes após a execução por meio de procedimentos mencionados anteriormente e, em seguida, recriar a biblioteca de classes é muito provável que o assembly será bloqueado pelos serviços de componente. Para contornar esse problema, use um dos seguintes métodos:
    • Clique com o botão direito do mouse o componente em Serviços de componentes e, em seguida, clique em Desligar .

      - ou -
    • Exclua o componente se desejar fazer alterações significativas em seu código.



Referências

Para obter informações adicionais sobre eventos menos rígidos, visite o seguinte site:
Using Loosely Coupled Events
Para obter informações adicionais sobre como implementar e implantar COM + configurados classes, visite o seguinte site:

Propriedades

ID do artigo: 318185 - Última revisão: segunda-feira, 24 de fevereiro de 2014 - Revisão: 3.3
A informação contida neste artigo aplica-se a:
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Bibliotecas de Classes do Microsoft .NET Framework 1.0
Palavras-chave: 
kbnosurvey kbarchive kbmt kbhowtomaster KB318185 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 318185

Submeter comentários

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com