Installer Classe

Référence

Définition

Espace de noms:: System.Configuration.Install

Assembly:: System.Configuration.Install.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit la base des installations personnalisées.

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. Quand Commit est sur le point de se terminer, Committing un é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 permettent d’installer des applications sur un ordinateur.

Vous devez suivre plusieurs étapes pour utiliser un Installer:

Héritez de la Installer classe .
Remplacez les Installméthodes , Commit, Rollbacket Uninstall .
Ajoutez le RunInstallerAttribute à votre classe dérivée et définissez-la 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 de Installer fait partie d’une collection du programme 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 , Commit, Rollbacket Uninstall de la Installer classe parcourent la collection de programmes d’installation stockées dans la Installers propriété et appellent la méthode correspondante de chaque programme d’installation.

Les Installméthodes , Commit, Rollbacket Uninstall ne 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. Au lieu de cela, utilisez un IDictionary qui est conservé entre les appels et transmis à vos Installméthodes , Commit, Rollbacket Uninstall .

Deux situations illustrent la nécessité d’enregistrer des informations dans l’économiseur IDictionaryd’état . Tout d’abord, supposons que votre programme d’installation définit une clé de Registre. Il doit enregistrer la valeur d’origine de la clé dans .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 .IDictionary Si l’installation est restaurée, le fichier le 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 qui a été entrée lors de l’exécution de l’exécutable d’installation.

Constructeurs

Installer()

Initialise une nouvelle instance de la classe Installer.

Propriétés

CanRaiseEvents	Obtient une valeur qui indique si le composant peut déclencher un événement. (Hérité de Component)
Container	Obtient le IContainer qui contient la Component. (Hérité de Component)
Context	Obtient ou définit des informations sur l'installation en cours.
DesignMode	Obtient une valeur qui indique si Component est actuellement en mode design. (Hérité de Component)
Events	Obtient la liste des gestionnaires d'événements attachés à ce Component. (Hérité de Component)
HelpText	Obtient le texte d’aide pour tous les programmes d’installation de la collection de programmes d’installation.
Installers	Obtient la collection de programmes d’installation contenue dans ce programme d’installation.
Parent	Obtient ou définit le programme d'installation contenant la collection à laquelle appartient ce programme d'installation.
Site	Obtient ou définit le ISite de Component. (Hérité de Component)

Méthodes

Commit(IDictionary)	En cas de substitution dans une classe dérivée, termine la transaction d’installation.
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
Dispose()	Libère toutes les ressources utilisées par Component. (Hérité de Component)
Dispose(Boolean)	Libère les ressources non managées utilisées par Component et libère éventuellement les ressources managées. (Hérité de Component)
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetService(Type)	Retourne un objet qui représente un service fourni par Component ou par son Container. (Hérité de Component)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
Install(IDictionary)	En cas de substitution dans une classe dérivée, exécute l'installation.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
OnAfterInstall(IDictionary)	Déclenche l’événement AfterInstall.
OnAfterRollback(IDictionary)	Déclenche l’événement AfterRollback.
OnAfterUninstall(IDictionary)	Déclenche l’événement AfterUninstall.
OnBeforeInstall(IDictionary)	Déclenche l’événement BeforeInstall.
OnBeforeRollback(IDictionary)	Déclenche l’événement BeforeRollback.
OnBeforeUninstall(IDictionary)	Déclenche l’événement BeforeUninstall.
OnCommitted(IDictionary)	Déclenche l’événement Committed.
OnCommitting(IDictionary)	Déclenche l’événement Committing.
Rollback(IDictionary)	En cas de substitution dans une classe dérivée, restaure l'état de l'ordinateur préalable à l'installation.
ToString()	Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée. (Hérité de Component)
Uninstall(IDictionary)	En cas de substitution dans une classe dérivée, supprime une installation.

Événements

AfterInstall	Se produit après l'exécution des méthodes Install(IDictionary) de tous les programmes d'installation de la propriété Installers.
AfterRollback	Se produit après la restauration des installations de tous les programmes d'installation de la propriété Installers.
AfterUninstall	Se produit une fois que tous les programmes d'installation de la propriété Installers ont effectué leurs propres opérations de désinstallation.
BeforeInstall	Se produit avant l’exécution de la méthode Install(IDictionary) de chaque programme d’installation contenu dans la collection de programmes d’installation.
BeforeRollback	Se produit avant la restauration des programmes d'installation de la propriété Installers.
BeforeUninstall	Se produit avant que les programmes d'installation de la propriété Installers aient effectué leurs propres opérations de désinstallation.
Committed	Se produit après la validation de l'installation de tous les programmes d'installation de la propriété Installers.
Committing	Se produit avant la validation de l’installation des programmes d’installation de la propriété Installers.
Disposed	Se produit lorsque le composant est supprimé par un appel à la méthode Dispose(). (Hérité de Component)

S’applique à

Partage via