(0) exportieren Drucken
Alle erweitern

Installer-Klasse

Stellt die Grundlage für benutzerdefinierte Installationen bereit.

Namespace: System.Configuration.Install
Assembly: System.Configuration.Install (in system.configuration.install.dll)

public class Installer : Component
public class Installer extends Component
public class Installer extends Component

Dies ist die Basisklasse für alle benutzerdefinierten Installationsprogramme in .NET Framework. Installationsprogramme sind Komponenten, mit deren Hilfe Anwendungen auf einem Computer installiert werden.

Sie müssen mehrere Schritte ausführen, um einen Installer verwenden zu können:

  • Vererben Sie die Installer-Klasse.

  • Überschreiben Sie die Methoden Install, Commit, Rollback und Uninstall.

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

  • Fügen Sie die abgeleitete Klasse der Assembly mit der zu installierenden Anwendung hinzu.

  • Rufen Sie die Installationsprogramme auf. Zum Aufrufen der Installationsprogramme können Sie z. B. InstallUtil.exe verwenden.

Die Installers-Eigenschaft enthält eine Auflistung von Installationsprogrammen. Wenn diese Instanz von Installer Teil einer Auflistung von Installationsprogrammen 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 unter der AssemblyInstaller-Klasse.

Die Install-Methode, die Commit-Methode, die Rollback-Methode und die Uninstall-Methode der Installer-Klasse durchlaufen die Auflistung der Installationsprogramme, die in der Installers-Eigenschaft gespeichert sind, und rufen die entsprechenden Methoden der einzelnen Installationsprogramme auf.

Die Methoden Install, Commit, Rollback und Uninstall werden nicht immer für dieselbe Installer-Instanz aufgerufen. Beispielsweise kann eine Installer-Instanz zum Installieren und für den Commit einer Anwendung verwendet und dann der Verweis auf diese Instanz freigegeben werden. Bei einer späteren Deinstallation der Anwendung wird ein Verweis auf eine neue Installer-Instanz erstellt. Dies bedeutet, dass die Uninstall-Methode durch eine andere Instanz von Installer aufgerufen wird. Aus diesem Grund sollte in einer abgeleiteten Klasse der Zustand eines Computers nicht in einem Installationsprogramm gespeichert werden. Verwenden Sie stattdessen ein IDictionary, das für alle Aufrufe beibehalten und an die Methoden Install, Commit, Rollback und Uninstall übergeben wird.

Die beiden folgenden Situationen veranschaulichen, warum Informationen in einem zum Speichern von Zuständen vorgesehenen IDictionary gespeichert werden sollten. Nehmen Sie zuerst an, dass das Installationsprogramm einen Registrierungsschlüssel festlegt. Der ursprüngliche Wert des Schlüssels sollte in IDictionary gespeichert werden. Wenn ein Rollback der Installation durchgeführt wird, kann der ursprüngliche Wert wiederhergestellt werden. Nehmen Sie nun weiterhin an, dass das Installationsprogramm eine vorhandene Datei ersetzt. Speichern Sie in diesem Fall die vorhandene Datei in einem temporären Verzeichnis und den neuen Speicherort der Datei in IDictionary. Wenn ein Rollback der Installation durchgeführt wird, wird die neuere Datei gelöscht und durch das Original aus dem temporären Verzeichnis ersetzt.

Die Installer.Context-Eigenschaft enthält Informationen über die Installation. Dazu gehören z. B. Informationen über den Speicherort der Protokolldatei für die Installation, den Speicherort der Datei, in der die von der Uninstall-Methode benötigten Informationen gespeichert werden, sowie die Befehlszeile, die beim Ausführen der Installationsdatei eingegeben wurde.

Im folgenden Beispiel wird die Verwendung der Installer-Klasse veranschaulicht. Dabei wird eine Klasse erstellt, die von Installer erbt. Kurz vor Beendigung von Commit tritt das Committing-Ereignis ein, und es wird eine Meldung angezeigt.

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 occured.");
      Console.WriteLine("");
   }
   // Event handler for 'Committed' event.
   private void MyInstaller_Committed(object sender, InstallEventArgs e)
   {
      Console.WriteLine("");
      Console.WriteLine("Committed Event occured.");
      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 ");
   }
}

import System.*;
import System.Collections.*;
import System.ComponentModel.*;
import System.Configuration.Install.*;

// Set 'RunInstaller' attribute to true.
/** @attribute RunInstaller(true)
 */
public class MyInstallerClass extends Installer
{
    public MyInstallerClass()
    {
        // Attach the 'Committed' event.
        this.add_Committed(new InstallEventHandler(MyInstaller_Committed));

        // Attach the 'Committing' event.
        this.add_Committing(new InstallEventHandler(MyInstaller_Committing));
    } //MyInstallerClass

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

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

    // Override the 'Install' method.
    public void Install(IDictionary savedState)
    {
        super.Install(savedState);
    } //Install

    // Override the 'Commit' method.
    public void Commit(IDictionary savedState)
    {
        super.Commit(savedState);
    } //Commit

    // Override the 'Rollback' method.
    public void Rollback(IDictionary savedState)
    {
        super.Rollback(savedState);
    } //Rollback

    public static void main(String[] args)
    {
        Console.WriteLine("Usage : installutil.exe Installer.exe ");
    } //main
} //MyInstallerClass

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0
Anzeigen:
© 2014 Microsoft