Installer Klasse

Referenz

Definition

Namespace:: System.Configuration.Install

Assembly:: System.Configuration.Install.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt die Grundlage für benutzerdefinierte Installationen bereit.

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

Installer()

Initialisiert eine neue Instanz der Installer-Klasse.

Eigenschaften

CanRaiseEvents	Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann. (Geerbt von Component)
Container	Ruft die IContainer ab, die in der Component enthalten ist. (Geerbt von Component)
Context	Ruft Informationen über die derzeitige Installation ab oder legt diese fest.
DesignMode	Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet. (Geerbt von Component)
Events	Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind. (Geerbt von Component)
HelpText	Ruft den Hilfetext für alle in der entsprechenden Auflistung enthaltenen Installationsprogramme ab.
Installers	Ruft die Auflistung von Installationsprogrammen ab, die dieses Installationsprogramm enthält.
Parent	Ruft das Installationsprogramm ab, das die Auflistung mit diesem Installationsprogramm enthält, oder legt dieses fest.
Site	Ruft den ISite von Component ab oder legt ihn fest. (Geerbt von Component)

Methoden

Commit(IDictionary)	Schließt beim Überschreiben in einer abgeleiteten Klasse die Installationstransaktion ab.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle vom Component verwendeten Ressourcen frei. (Geerbt von Component)
Dispose(Boolean)	Gibt die von Component verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von Component)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetService(Type)	Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt. (Geerbt von Component)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
Install(IDictionary)	Führt beim Überschreiben in einer abgeleiteten Klasse die Installation aus.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
OnAfterInstall(IDictionary)	Löst das AfterInstall-Ereignis aus.
OnAfterRollback(IDictionary)	Löst das AfterRollback-Ereignis aus.
OnAfterUninstall(IDictionary)	Löst das AfterUninstall-Ereignis aus.
OnBeforeInstall(IDictionary)	Löst das BeforeInstall-Ereignis aus.
OnBeforeRollback(IDictionary)	Löst das BeforeRollback-Ereignis aus.
OnBeforeUninstall(IDictionary)	Löst das BeforeUninstall-Ereignis aus.
OnCommitted(IDictionary)	Löst das Committed-Ereignis aus.
OnCommitting(IDictionary)	Löst das Committing-Ereignis aus.
Rollback(IDictionary)	Stellt beim Überschreiben in einer abgeleiteten Klasse den Zustand wieder her, in dem sich der Computer vor der Installation befand.
ToString()	Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden). Diese Methode darf nicht überschrieben werden. (Geerbt von Component)
Uninstall(IDictionary)	Entfernt beim Überschreiben in einer abgeleiteten Klasse eine Installation.

Ereignisse

AfterInstall	Tritt ein, nachdem die Install(IDictionary)-Methoden aller in der Installers-Eigenschaft enthaltenen Installationsprogramme ausgeführt wurden.
AfterRollback	Tritt ein, nachdem ein Rollback aller Installationen der Installationsprogramme in der Installers-Eigenschaft ausgeführt wurde.
AfterUninstall	Tritt ein, nachdem alle Installationsprogramme in der Installers-Eigenschaft ihre jeweiligen Deinstallationsvorgänge ausgeführt haben.
BeforeInstall	Tritt ein, bevor die Install(IDictionary)-Methode aller in der Auflistung der Installationsprogramme enthaltenen Installationsprogramme ausgeführt worden ist.
BeforeRollback	Tritt ein, bevor ein Rollback der Installationsprogramme in der Installers-Eigenschaft ausgeführt wird.
BeforeUninstall	Tritt ein, bevor die Installationsprogramme in der Installers-Eigenschaft ihre jeweiligen Deinstallationsvorgänge ausführen.
Committed	Tritt ein, nachdem alle Installationsprogramme in der Installers-Eigenschaft ein Commit für ihre Installationen ausgeführt haben.
Committing	Tritt ein, bevor die Installationsprogramme in der Installers-Eigenschaft ein Commit für ihre Installationen ausführen.
Disposed	Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird. (Geerbt von Component)

Gilt für:

Teilen über