Installer Classe

Définition

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

public class Installer : System.ComponentModel.Component

type Installer = class
    inherit Component

Public Class Installer
Inherits Component

Héritage

Object

MarshalByRefObject

Component

Installer

Dérivé

System.Configuration.Install.AssemblyInstaller

System.Configuration.Install.ComponentInstaller

System.Configuration.Install.TransactedInstaller

System.Management.Instrumentation.DefaultManagementInstaller

System.Management.Instrumentation.DefaultManagementProjectInstaller

Plus…

Exemples

L’exemple suivant illustre l’utilisation de la Installer classe. Il crée une classe qui hérite de Installer. Lorsqu’il Commit est sur le point de se terminer, Committing l’événement se produit et un message s’affiche. Pour utiliser la Installer classe, vous devez référencer l’assembly System.Configuration.Install dans votre projet.

#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

Remarques

Il s’agit de la classe de base pour tous les programmes d’installation personnalisés dans le .NET Framework. Les programmes d’installation sont des composants qui aident à installer des applications sur un ordinateur.

Vous devez suivre plusieurs étapes pour utiliser un Installer:

• Héritez de la Installer classe.

• Remplacez les méthodes , et UninstallRollbackremplacez Commitles Installméthodes.

• Ajoutez la classe dérivée et définissez-la RunInstallerAttribute sur true.

• Placez votre classe dérivée dans l’assembly avec votre application à installer.

• Appelez les programmes d’installation. Par exemple, utilisez le InstallUtil.exe pour appeler les programmes d’installation.

La Installers propriété contient une collection de programmes d’installation. Si cette instance fait Installer partie d’une collection d’programmes d’installation, la Parent propriété est définie sur l’instance Installer qui contient la collection. Pour obtenir un exemple d’utilisation de la Installers collection, consultez la AssemblyInstaller classe.

Les Installméthodes , et les UninstallRollbackméthodes Commitde la Installer classe passent par la collection de programmes d’installation stockés dans la Installers propriété et appellent la méthode correspondante de chaque programme d’installation.

Les Installméthodes , et les UninstallRollbackméthodes Commitne sont pas toujours appelées sur la même Installer instance. Par exemple, une Installer instance peut être utilisée lors de l’installation et de la validation d’une application, puis la référence à cette instance est publiée. Plus tard, la désinstallation de l’application crée une référence à une nouvelle Installer instance, ce qui signifie que la Uninstall méthode est appelée par une autre instance de Installer. Pour cette raison, dans votre classe dérivée, n’enregistrez pas l’état d’un ordinateur dans un programme d’installation. Utilisez plutôt un IDictionary qui est conservé entre les appels et transmis à vos méthodes, Commitet RollbackUninstall à vos Installméthodes.

Deux situations illustrent la nécessité d’enregistrer des informations dans l’état-saver IDictionary. Tout d’abord, supposons que votre programme d’installation définit une clé de Registre. Elle doit enregistrer la valeur d’origine de la clé dans le IDictionary. Si l’installation est restaurée, la valeur d’origine peut être restaurée. Ensuite, supposons que le programme d’installation remplace un fichier existant. Enregistrez le fichier existant dans un répertoire temporaire et l’emplacement du nouvel emplacement du fichier dans le IDictionary. Si l’installation est restaurée, le fichier plus récent est supprimé et remplacé par l’original à partir de l’emplacement temporaire.

La Installer.Context propriété contient des informations sur l’installation. Par exemple, des informations sur l’emplacement du fichier journal pour l’installation, l’emplacement du fichier pour enregistrer les informations requises par la Uninstall méthode et la ligne de commande entrée lors de l’exécution de l’exécutable d’installation.

Voir aussi

• AssemblyInstaller
• ComponentInstaller
• InstallerCollection
• TransactedInstaller
• Installutil.exe (outil programme d’installation)