Installer-Klasse
Stellt die Grundlage für benutzerdefinierte Installationen bereit.
Namespace: System.Configuration.Install
Assembly: System.Configuration.Install (in system.configuration.install.dll)
Syntax
'Declaration
Public Class Installer
Inherits Component
'Usage
Dim instance As Installer
public class Installer : Component
public ref class Installer : public Component
public class Installer extends Component
public class Installer extends Component
Hinweise
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.
Beispiel
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.
Imports System
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 'New
' Event handler for 'Committing' event.
Private Sub MyInstaller_Committing(ByVal sender As Object, _
ByVal e As InstallEventArgs)
Console.WriteLine("")
Console.WriteLine("Committing Event occured.")
Console.WriteLine("")
End Sub 'MyInstaller_Committing
' Event handler for 'Committed' event.
Private Sub MyInstaller_Committed(ByVal sender As Object, _
ByVal e As InstallEventArgs)
Console.WriteLine("")
Console.WriteLine("Committed Event occured.")
Console.WriteLine("")
End Sub 'MyInstaller_Committed
' Override the 'Install' method.
Public Overrides Sub Install(ByVal savedState As IDictionary)
MyBase.Install(savedState)
End Sub 'Install
' Override the 'Commit' method.
Public Overrides Sub Commit(ByVal savedState As IDictionary)
MyBase.Commit(savedState)
End Sub 'Commit
' Override the 'Rollback' method.
Public Overrides Sub Rollback(ByVal savedState As IDictionary)
MyBase.Rollback(savedState)
End Sub 'Rollback
Public Shared Sub Main()
Console.WriteLine("Usage : installutil.exe Installer.exe ")
End Sub 'Main
End Class 'MyInstallerClass
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 ");
}
}
#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 occured." );
Console::WriteLine( "" );
}
// Event handler for 'Committed' event.
void MyInstaller_Committed( Object^ sender, InstallEventArgs^ e )
{
Console::WriteLine( "" );
Console::WriteLine( "Committed Event occured." );
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 " );
}
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
Vererbungshierarchie
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.Configuration.Install.Installer
System.Configuration.Install.AssemblyInstaller
System.Configuration.Install.ComponentInstaller
System.Configuration.Install.TransactedInstaller
System.Management.Instrumentation.DefaultManagementProjectInstaller
System.Management.Instrumentation.ManagementInstaller
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
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.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
Siehe auch
Referenz
Installer-Member
System.Configuration.Install-Namespace
AssemblyInstaller-Klasse
ComponentInstaller-Klasse
InstallerCollection
TransactedInstaller