Installer Classe

Definição

public ref class Installer : System::ComponentModel::Component

public class Installer : System.ComponentModel.Component

type Installer = class
    inherit Component

Public Class Installer
Inherits Component

Herança

Object

MarshalByRefObject

Component

Installer

Derivado

System.Configuration.Install.AssemblyInstaller

System.Configuration.Install.ComponentInstaller

System.Configuration.Install.TransactedInstaller

System.Management.Instrumentation.DefaultManagementInstaller

System.Management.Instrumentation.DefaultManagementProjectInstaller

Mais…

Exemplos

O exemplo a seguir demonstra o uso da Installer classe . Ele cria uma classe que herda de Installer. Quando Commit está prestes a ser concluído, Committing o evento ocorre e uma mensagem é exibida. Para usar a Installer classe , você deve referenciar o assembly System.Configuration.Install em seu projeto.

#using <System.dll>
#using <System.Configuration.Install.dll>

using namespace System;
using namespace System::Collections;
using namespace System::ComponentModel;
using namespace System::Configuration::Install;

// Set 'RunInstaller' attribute to true.

[RunInstaller(true)]
ref class MyInstallerClass: public Installer
{
private:

   // Event handler for 'Committing' event.
   void MyInstaller_Committing( Object^ sender, InstallEventArgs^ e )
   {
      Console::WriteLine( "" );
      Console::WriteLine( "Committing Event occurred." );
      Console::WriteLine( "" );
   }


   // Event handler for 'Committed' event.
   void MyInstaller_Committed( Object^ sender, InstallEventArgs^ e )
   {
      Console::WriteLine( "" );
      Console::WriteLine( "Committed Event occurred." );
      Console::WriteLine( "" );
   }


public:
   MyInstallerClass()
   {
      
      // Attach the 'Committed' event.
      this->Committed += gcnew InstallEventHandler( this, &MyInstallerClass::MyInstaller_Committed );
      
      // Attach the 'Committing' event.
      this->Committing += gcnew InstallEventHandler( this, &MyInstallerClass::MyInstaller_Committing );
   }


   // Override the 'Install' method.
   virtual void Install( IDictionary^ savedState ) override
   {
      Installer::Install( savedState );
   }


   // Override the 'Commit' method.
   virtual void Commit( IDictionary^ savedState ) override
   {
      Installer::Commit( savedState );
   }


   // Override the 'Rollback' method.
   virtual void Rollback( IDictionary^ savedState ) override
   {
      Installer::Rollback( savedState );
   }

};

int main()
{
   Console::WriteLine( "Usage : installutil.exe Installer.exe " );
}

using System;
using System.Collections;
using System.ComponentModel;
using System.Configuration.Install;

// Set 'RunInstaller' attribute to true.
[RunInstaller(true)]
public class MyInstallerClass: Installer
{
   public MyInstallerClass() :base()
   {
      // Attach the 'Committed' event.
      this.Committed += new InstallEventHandler(MyInstaller_Committed);
      // Attach the 'Committing' event.
      this.Committing += new InstallEventHandler(MyInstaller_Committing);
   }
   // Event handler for 'Committing' event.
   private void MyInstaller_Committing(object sender, InstallEventArgs e)
   {
      Console.WriteLine("");
      Console.WriteLine("Committing Event occurred.");
      Console.WriteLine("");
   }
   // Event handler for 'Committed' event.
   private void MyInstaller_Committed(object sender, InstallEventArgs e)
   {
      Console.WriteLine("");
      Console.WriteLine("Committed Event occurred.");
      Console.WriteLine("");
   }
   // Override the 'Install' method.
   public override void Install(IDictionary savedState)
   {
      base.Install(savedState);
   }
   // Override the 'Commit' method.
   public override void Commit(IDictionary savedState)
   {
      base.Commit(savedState);
   }
   // Override the 'Rollback' method.
   public override void Rollback(IDictionary savedState)
   {
      base.Rollback(savedState);
   }
   public static void Main()
   {
      Console.WriteLine("Usage : installutil.exe Installer.exe ");
   }
}

Imports System.Collections
Imports System.ComponentModel
Imports System.Configuration.Install

' Set 'RunInstaller' attribute to true.
<RunInstaller(True)> _
Public Class MyInstallerClass
   Inherits Installer

   Public Sub New()
       MyBase.New()
      ' Attach the 'Committed' event.
      AddHandler Me.Committed, AddressOf MyInstaller_Committed
      ' Attach the 'Committing' event.
      AddHandler Me.Committing, AddressOf MyInstaller_Committing
   End Sub

   ' Event handler for 'Committing' event.
   Private Sub MyInstaller_Committing(ByVal sender As Object, _
                                      ByVal e As InstallEventArgs)
      Console.WriteLine("")
      Console.WriteLine("Committing Event occurred.")
      Console.WriteLine("")
   End Sub

   ' Event handler for 'Committed' event.
   Private Sub MyInstaller_Committed(ByVal sender As Object, _
                                     ByVal e As InstallEventArgs)
      Console.WriteLine("")
      Console.WriteLine("Committed Event occurred.")
      Console.WriteLine("")
   End Sub

   ' Override the 'Install' method.
   Public Overrides Sub Install(ByVal savedState As IDictionary)
      MyBase.Install(savedState)
   End Sub

   ' Override the 'Commit' method.
   Public Overrides Sub Commit(ByVal savedState As IDictionary)
      MyBase.Commit(savedState)
   End Sub

   ' Override the 'Rollback' method.
   Public Overrides Sub Rollback(ByVal savedState As IDictionary)
      MyBase.Rollback(savedState)
   End Sub
   Public Shared Sub Main()
      Console.WriteLine("Usage : installutil.exe Installer.exe ")
   End Sub
End Class

Comentários

Essa é a classe base para todos os instaladores personalizados no .NET Framework. Os instaladores são componentes que ajudam a instalar aplicativos em um computador.

Há várias etapas que você deve seguir para usar um Installer:

• Herda a Installer classe .

• Substitua os Installmétodos , Commit, Rollbacke Uninstall .

• Adicione o RunInstallerAttribute à classe derivada e defina-o truecomo .

• Coloque sua classe derivada no assembly com seu aplicativo para instalar.

• Invoque os instaladores. Por exemplo, use o InstallUtil.exe para invocar os instaladores.

A Installers propriedade contém uma coleção de instaladores. Se essa instância do Installer fizer parte de uma coleção de instalador, a Parent propriedade será definida como a Installer instância que contém a coleção. Para obter um exemplo do uso da Installers coleção, consulte a AssemblyInstaller classe .

Os Installmétodos , CommitRollback, e Uninstall da Installer classe passam pela coleção de instaladores armazenados na Installers propriedade e invocam o método correspondente de cada instalador.

Os Installmétodos , CommitRollback, e Uninstall nem sempre são chamados na mesma Installer instância. Por exemplo, uma Installer instância pode ser usada durante a instalação e confirmação de um aplicativo e, em seguida, a referência a essa instância é liberada. Posteriormente, a desinstalação do aplicativo cria uma referência a uma nova Installer instância, o que significa que o Uninstall método é chamado por uma instância diferente do Installer. Por esse motivo, em sua classe derivada, não salve o estado de um computador em um instalador. Em vez disso, use um IDictionary que é preservado entre chamadas e passado para seus Installmétodos , Commit, Rollbacke Uninstall .

Duas situações ilustram a necessidade de salvar informações no state-saver IDictionary. Primeiro, suponha que o instalador defina uma chave do Registro. Ele deve salvar o valor original da chave no IDictionary. Se a instalação for revertida, o valor original poderá ser restaurado. Em segundo lugar, suponha que o instalador substitua um arquivo existente. Salve o arquivo existente em um diretório temporário e o local do novo local do arquivo no IDictionary. Se a instalação for revertida, o arquivo mais recente será excluído e substituído pelo original do local temporário.

A Installer.Context propriedade contém informações sobre a instalação. Por exemplo, informações sobre o local do arquivo de log para a instalação, o local do arquivo para salvar as informações exigidas pelo Uninstall método e a linha de comando que foi inserida quando o executável de instalação foi executado.

Construtores

Propriedades

Métodos

Eventos

Aplica-se a

Confira também

• AssemblyInstaller
• ComponentInstaller
• InstallerCollection
• TransactedInstaller
• Installutil.exe (Ferramenta de Instalação)