Installer Klasse

Definition

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

public class Installer : System.ComponentModel.Component

type Installer = class
    inherit Component

Public Class Installer
Inherits Component

Vererbung

Object

MarshalByRefObject

Component

Installer

Abgeleitet

System.Configuration.Install.AssemblyInstaller

System.Configuration.Install.ComponentInstaller

System.Configuration.Install.TransactedInstaller

System.Management.Instrumentation.DefaultManagementInstaller

System.Management.Instrumentation.DefaultManagementProjectInstaller

Mehr …

Beispiele

Im folgenden Beispiel wird die Verwendung der Installer -Klasse veranschaulicht. Sie erstellt eine Klasse, die von Installererbt. Wenn Commit der Abschluss abgeschlossen ist, Committing tritt das Ereignis auf, und es wird eine Meldung angezeigt. Um die Installer -Klasse zu verwenden, müssen Sie auf die System.Configuration.Install-Assembly in Ihrem Projekt verweisen.

#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

Hinweise

Dies ist die Basisklasse für alle benutzerdefinierten Installationsprogramme in .NET Framework. Installationsprogramme sind Komponenten, die bei der Installation von Anwendungen auf einem Computer helfen.

Es gibt mehrere Schritte, die Sie ausführen müssen, um einen Installerzu verwenden:

• Erben Sie die Installer -Klasse.

• Überschreiben Sie die InstallMethoden , Commit, Rollbackund Uninstall .

• Fügen Sie der abgeleiteten Klasse hinzu RunInstallerAttribute , und legen Sie es auf fest true.

• Platzieren Sie Ihre abgeleitete Klasse in der Assembly mit der zu installierenden Anwendung.

• Rufen Sie die Installationsprogramme auf. Verwenden Sie beispielsweise die InstallUtil.exe, um die Installationsprogramme aufzurufen.

Die Installers -Eigenschaft enthält eine Auflistung von Installern. Wenn diese Instanz von Installer Teil einer Installerauflistung ist, wird die Parent -Eigenschaft auf die Installer Instanz festgelegt, die die Auflistung enthält. Ein Beispiel für die Verwendung der Installers Auflistung finden Sie in der AssemblyInstaller -Klasse.

Die InstallMethoden , Commit, Rollback, und Uninstall der Installer -Klasse durchlaufen die Auflistung von Installern, die in der Installers -Eigenschaft gespeichert sind, und rufen die entsprechende Methode jedes Installers auf.

Die InstallMethoden , Commit, Rollbackund Uninstall werden nicht immer für dieselbe Installer Instanz aufgerufen. Beispielsweise kann eine Installer Instanz beim Installieren und Commiten einer Anwendung verwendet werden, und dann wird der Verweis auf diese Instanz freigegeben. Durch das Deinstallieren der Anwendung wird später ein Verweis auf eine neue Installer Instanz erstellt, was bedeutet, dass die Uninstall -Methode von einer anderen Instanz von Installeraufgerufen wird. Aus diesem Grund speichern Sie in Ihrer abgeleiteten Klasse den Zustand eines Computers nicht in einem Installationsprogramm. Verwenden Sie stattdessen ein IDictionary , das aufrufübergreifend beibehalten und an Ihre InstallMethoden , Commit, , Rollbackund Uninstall übergeben wird.

Zwei Situationen veranschaulichen die Notwendigkeit, Informationen im Zustandsschoner IDictionaryzu speichern. Angenommen, Ihr Installationsprogramm legt einen Registrierungsschlüssel fest. Es sollte den ursprünglichen Wert des Schlüssels in speichern IDictionary. Wenn für die Installation ein Rollback ausgeführt wird, kann der ursprüngliche Wert wiederhergestellt werden. Angenommen, das Installationsprogramm ersetzt eine vorhandene Datei. Speichern Sie die vorhandene Datei in einem temporären Verzeichnis und den Speicherort des neuen Speicherorts der Datei in der IDictionary. Wenn für die Installation ein Rollback ausgeführt wird, wird die neuere Datei gelöscht und durch das Original aus dem temporären Speicherort ersetzt.

Die Installer.Context -Eigenschaft enthält Informationen zur Installation. Beispielsweise Informationen über den Speicherort der Protokolldatei für die Installation, den Speicherort der Datei zum Speichern der von der Uninstall Methode benötigten Informationen und die Befehlszeile, die beim Ausführen der ausführbaren Installationsdatei eingegeben wurde.

Konstruktoren

Eigenschaften

Methoden

Ereignisse

Gilt für:

Weitere Informationen

• AssemblyInstaller
• ComponentInstaller
• InstallerCollection
• TransactedInstaller
• Installutil.exe (Installer-Tool)