InstallerCollection Klasse

Definition

Enthält eine Auflistung der Installationsprogramme, die während einer Installation ausgeführt werden sollen.

public ref class InstallerCollection : System::Collections::CollectionBase
public class InstallerCollection : System.Collections.CollectionBase
type InstallerCollection = class
    inherit CollectionBase
Public Class InstallerCollection
Inherits CollectionBase
Vererbung
InstallerCollection

Beispiele

Im folgenden Beispiel wird die Add Methode der InstallerCollection Klasse veranschaulicht. In diesem Beispiel wird eine Implementierung wieInstallutil.exe (Installer Tool) bereitgestellt. Es installiert Assemblys mit den Optionen vor dieser bestimmten Assembly. Wenn eine Option für eine Assembly nicht angegeben wird, werden die Optionen der vorherigen Assembly ausgeführt, wenn eine vorherige Assembly in der Liste vorhanden ist. Wenn die Option "/u" oder "/deinstallieren" angegeben ist, werden die Assemblys deinstalliert. Wenn das "/?" oder die Option "/Hilfe" wird bereitgestellt, die Hilfeinformationen werden auf der Konsole angezeigt.

#using <System.dll>
#using <System.Configuration.Install.dll>

using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Configuration::Install;
using namespace System::IO;

void PrintHelpMessage()
{
   Console::WriteLine( "Usage : InstallerCollection_Add [/u | /uninstall] [option [...]] assembly " +
      "[[option [...]] assembly] [...]]" );
   Console::WriteLine( "InstallerCollection_Add executes the installers in each of" +
      "the given assembly. If /u or /uninstall option" + 
      "option is given it uninstalls the assemblies." );
}

int main()
{
   array<String^>^ args = Environment::GetCommandLineArgs();
   ArrayList^ options = gcnew ArrayList;
   String^ myOption;
   bool toUnInstall = false;
   bool toPrintHelp = false;
   TransactedInstaller^ myTransactedInstaller = gcnew TransactedInstaller;
   AssemblyInstaller^ myAssemblyInstaller;
   InstallContext^ myInstallContext;

   try
   {
      for ( int i = 0; i < args->Length; i++ )
      {
         // Process the arguments.
         if ( args[ i ]->StartsWith( "/" ) || args[ i ]->StartsWith( "-" ) )
         {
            myOption = args[ i ]->Substring( 1 );
            // Determine whether the option is to 'uninstall' a assembly.
            if ( String::Compare( myOption, "u", true ) == 0 ||
               String::Compare( myOption, "uninstall", true ) == 0 )
            {
               toUnInstall = true;
               continue;
            }
            // Determine whether the option is for printing help information.
            if ( String::Compare( myOption, "?", true ) == 0 ||
               String::Compare( myOption, "help", true ) == 0 )
            {
               toPrintHelp = true;
               continue;
            }
            // Add the option encountered to the list of all options
            // encountered for the current assembly.
            options->Add( myOption );
         }
         else
         {
            // Determine whether the assembly file exists.
            if (  !File::Exists( args[ i ] ) )
            {
               // If assembly file doesn't exist then print error.
               Console::WriteLine( " Error : {0} - Assembly file doesn't exist.", args[ i ] );
               return 0;
            }
            // Create an instance of 'AssemblyInstaller' that installs the given assembly.
            myAssemblyInstaller = gcnew AssemblyInstaller( args[ i ],
              (array<String^>^)(options->ToArray( String::typeid )) );
            // Add the instance of 'AssemblyInstaller' to the 'TransactedInstaller'.
            myTransactedInstaller->Installers->Add( myAssemblyInstaller );
         }
      }
      // then print help message.
      if ( toPrintHelp || myTransactedInstaller->Installers->Count == 0 )
      {
         PrintHelpMessage();
         return 0;
      }

      // Create an instance of 'InstallContext' with the options specified.
      myInstallContext =
         gcnew InstallContext( "Install.log",
              (array<String^>^)(options->ToArray( String::typeid )) );
      myTransactedInstaller->Context = myInstallContext;

      // Install or Uninstall an assembly depending on the option provided.
      if (  !toUnInstall )
         myTransactedInstaller->Install( gcnew Hashtable );
      else
         myTransactedInstaller->Uninstall( nullptr );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( " Exception raised : {0}", e->Message );
   }
}
using System;
using System.ComponentModel;
using System.Collections;
using System.Configuration.Install;
using System.IO;

public class InstallerCollection_Add
{
   public static void Main(String[] args)
   {
      ArrayList options = new ArrayList();
      String myOption;
      bool toUnInstall = false;
      bool toPrintHelp = false;
      TransactedInstaller myTransactedInstaller = new TransactedInstaller();
      AssemblyInstaller myAssemblyInstaller;
      InstallContext myInstallContext;

      try
      {
         for(int i = 0; i < args.Length; i++)
         {
            // Process the arguments.
            if(args[i].StartsWith("/") || args[i].StartsWith("-"))
            {
               myOption = args[i].Substring(1);
               // Determine whether the option is to 'uninstall' a assembly.
               if(String.Compare(myOption, "u", true) == 0 ||
                  String.Compare(myOption, "uninstall", true) == 0)
               {
                  toUnInstall = true;
                  continue;
               }
               // Determine whether the option is for printing help information.
               if(String.Compare(myOption, "?", true) == 0 ||
                  String.Compare(myOption, "help", true) == 0)
               {
                  toPrintHelp = true;
                  continue;
               }
               // Add the option encountered to the list of all options
               // encountered for the current assembly.
               options.Add(myOption);
            }
            else
            {
               // Determine whether the assembly file exists.
               if(!File.Exists(args[i]))
               {
                  // If assembly file doesn't exist then print error.
                  Console.WriteLine(" Error : {0} - Assembly file doesn't exist.", args[i]);
                  return;
               }
               // Create an instance of 'AssemblyInstaller' that installs the given assembly.
               myAssemblyInstaller = new AssemblyInstaller(args[i],
                  (string[]) options.ToArray(typeof(string)));
               // Add the instance of 'AssemblyInstaller' to the 'TransactedInstaller'.
               myTransactedInstaller.Installers.Add(myAssemblyInstaller);
            }
         }
         // If user requested help or didn't provide any assemblies to install
         // then print help message.
         if(toPrintHelp || myTransactedInstaller.Installers.Count == 0)
         {
            PrintHelpMessage();
            return;
         }

         // Create an instance of 'InstallContext' with the options specified.
         myInstallContext =
            new InstallContext("Install.log",
            (string[]) options.ToArray(typeof(string)));
         myTransactedInstaller.Context = myInstallContext;

         // Install or Uninstall an assembly depending on the option provided.
         if(!toUnInstall)
            myTransactedInstaller.Install(new Hashtable());
         else
            myTransactedInstaller.Uninstall(null);
      }
      catch(Exception e)
      {
         Console.WriteLine(" Exception raised : {0}", e.Message);
      }
   }

   public static void PrintHelpMessage()
   {
      Console.WriteLine("Usage : InstallerCollection_Add [/u | /uninstall] [option [...]] assembly" +
         "[[option [...]] assembly] [...]]");
      Console.WriteLine("InstallerCollection_Add executes the installers in each of" +
         " the given assembly. If /u or /uninstall option" +
         " is given it uninstalls the assemblies.");
   }
}
Imports System.ComponentModel
Imports System.Collections
Imports System.Configuration.Install
Imports System.IO

Public Class InstallerCollection_Add
   
   'Entry point which delegates to C-style main Private Function
   Public Overloads Shared Sub Main()
      Main(System.Environment.GetCommandLineArgs())
   End Sub
   
   Overloads Public Shared Sub Main(args() As String)
      Dim options As New ArrayList()
      Dim myOption As String
      Dim toUnInstall As Boolean = False
      Dim toPrintHelp As Boolean = False
      Dim myTransactedInstaller As New TransactedInstaller()
      Dim myAssemblyInstaller As AssemblyInstaller
      Dim myInstallContext As InstallContext
      
      Try
         Dim i As Integer
         For i = 1 To args.Length - 1
            ' Process the arguments.
            If args(i).StartsWith("/") Or args(i).StartsWith("-") Then
               myOption = args(i).Substring(1)
               ' Determine whether the option is to 'uninstall' a assembly.
               If String.Compare(myOption, "u", True) = 0 Or String.Compare(myOption, "uninstall", _
                                                                              True) = 0 Then
                  toUnInstall = True
                  GoTo ContinueFor1
               End If
               ' Determine whether the option is for printing help information.
               If String.Compare(myOption, "?", True) = 0 Or String.Compare(myOption, "help", _
                                                                                 True) = 0 Then
                  toPrintHelp = True
                  GoTo ContinueFor1
               End If
               ' Add the option encountered to the list of all options
               ' encountered for the current assembly.
               options.Add(myOption)
            Else
               ' Determine whether the assembly file exists.
               If Not File.Exists(args(i)) Then
                  ' If assembly file doesn't exist then print error.
                  Console.WriteLine(" Error : {0} - Assembly file doesn't exist.", args(i))
                  Return
               End If
               ' Create an instance of 'AssemblyInstaller' that installs the given assembly.
               myAssemblyInstaller = New AssemblyInstaller(args(i), CType(options.ToArray _
                                                               (GetType(String)), String()))
               ' Add the instance of 'AssemblyInstaller' to the 'TransactedInstaller'.
               myTransactedInstaller.Installers.Add(myAssemblyInstaller)
            End If
         ContinueFor1: 
         Next i
         ' If user requested help or didn't provide any assemblies to install
         ' then print help message.
         If toPrintHelp Or myTransactedInstaller.Installers.Count = 0 Then
            PrintHelpMessage()
            Return
         End If
         
         ' Create an instance of 'InstallContext' with the options specified.
         myInstallContext = New InstallContext("Install.log", CType(options.ToArray _
                                                               (GetType(String)), String()))
         myTransactedInstaller.Context = myInstallContext
         
         ' Install or Uninstall an assembly depending on the option provided.
         If Not toUnInstall Then
            myTransactedInstaller.Install(New Hashtable())
         Else
            myTransactedInstaller.Uninstall(Nothing)
         End If
      Catch e As Exception
         Console.WriteLine(" Exception raised : {0}", e.Message)
      End Try
   End Sub

   Public Shared Sub PrintHelpMessage()
      Console.WriteLine("Usage : InstallerCollection_Add [/u | /uninstall] [option [...]]assembly"+ _
                                                               "[[option [...]] assembly] [...]]")
      Console.WriteLine("InstallerCollection_Add executes the installers in each of" + _
      " the given assembly. If /u or /uninstall option is given it uninstalls the assemblies.")
   End Sub
End Class

Hinweise

Dies InstallerCollection stellt die Methoden und Eigenschaften bereit, die Ihre Anwendung zum Verwalten einer Auflistung von Installer Objekten benötigt.

Verwenden Sie eine der folgenden drei Methoden zum Hinzufügen von Installern zur Auflistung:

  • Die Add Methode fügt der Auflistung ein einzelnes Installationsprogramm hinzu.

  • Die AddRange Methoden fügen der Auflistung mehrere Installer hinzu.

  • Die Insert Methode und die Item[] Eigenschaft, die der InstallerCollection Indexer ist, fügen jedes ein einzelnes Installationsprogramm zur Auflistung im angegebenen Index hinzu.

Entfernen Sie Installationsprogramme über die Remove Methode. Überprüfen Sie, ob sich ein Installationsprogramm in der Auflistung befindet, indem Sie die Contains Methode verwenden. Suchen Sie, wo sich ein Installationsprogramm in der Auflistung befindet, indem Sie die IndexOf Methode verwenden.

Die Installationsprogramme in einer Auflistung werden ausgeführt, wenn das Installationsprogramm, das die Auflistung enthält, wie durch die Installer.Parent Eigenschaft angegeben, ihre RollbackInstallCommit, oder Uninstall Methoden aufruft.

Beispiele für die Verwendung einer Installersammlung finden Sie unter den AssemblyInstaller und TransactedInstaller Klassen.

Eigenschaften

Capacity

Ruft die Anzahl der Elemente ab, die die CollectionBase enthalten kann, oder legt diese fest.

(Geerbt von CollectionBase)
Count

Ruft die Anzahl der in der CollectionBase-Instanz enthaltenen Elemente ab. Diese Eigenschaft kann nicht überschrieben werden.

(Geerbt von CollectionBase)
InnerList

Ruft eine ArrayList mit der Liste der Elemente in der CollectionBase-Instanz ab.

(Geerbt von CollectionBase)
Item[Int32]

Ruft ein Installationsprogramm am angegebenen Index ab oder legt dieses fest.

List

Ruft eine IList mit der Liste der Elemente in der CollectionBase-Instanz ab.

(Geerbt von CollectionBase)

Methoden

Add(Installer)

Fügt dieser Auflistung von Installationsprogrammen das angegebene Installationsprogramm hinzu.

AddRange(Installer[])

Fügt dieser Auflistung das angegebene Array von Installationsprogrammen hinzu.

AddRange(InstallerCollection)

Fügt dieser Auflistung die angegebene Auflistung von Installationsprogrammen hinzu.

Clear()

Entfernt alle Objekte aus der CollectionBase-Instanz. Diese Methode kann nicht überschrieben werden.

(Geerbt von CollectionBase)
Contains(Installer)

Bestimmt, ob das angegebene Installationsprogramm in der Auflistung enthalten ist.

CopyTo(Installer[], Int32)

Kopiert die Elemente aus der Sammlung in ein Array, beginnend am angegebenen Index.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetEnumerator()

Gibt einen Enumerator zurück, der die CollectionBase durchläuft.

(Geerbt von CollectionBase)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
IndexOf(Installer)

Bestimmt den Index eines bestimmten Installationsprogramms in der Auflistung.

Insert(Int32, Installer)

Fügt das angegebene Installationsprogramm am angegebenen Index in die Auflistung ein.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
OnClear()

Führt beim Löschen des Inhalts der CollectionBase-Instanz zusätzliche benutzerdefinierte Prozesse aus.

(Geerbt von CollectionBase)
OnClearComplete()

Führt nach dem Löschen des Inhalts der CollectionBase-Instanz zusätzliche benutzerdefinierte Prozesse aus.

(Geerbt von CollectionBase)
OnInsert(Int32, Object)

Führt vor dem Einfügen eines neuen Installationsprogramms in die Auflistung zusätzliche benutzerdefinierte Prozesse aus.

OnInsertComplete(Int32, Object)

Führt zusätzliche benutzerdefinierte Prozesse nach dem Einfügen eines neuen Elements in die CollectionBase-Instanz aus.

(Geerbt von CollectionBase)
OnRemove(Int32, Object)

Führt zusätzliche benutzerdefinierte Prozesse aus, bevor ein Installationsprogramm aus der Auflistung entfernt wird.

OnRemoveComplete(Int32, Object)

Führt zusätzliche benutzerdefinierte Prozesse nach dem Entfernen eines Elements aus der CollectionBase-Instanz aus.

(Geerbt von CollectionBase)
OnSet(Int32, Object, Object)

Führt zusätzliche benutzerdefinierte Prozesse aus, bevor ein vorhandenes Installationsprogramm auf einen neuen Wert festgelegt wird.

OnSetComplete(Int32, Object, Object)

Führt zusätzliche benutzerdefinierte Prozesse nach dem Festlegen eines Werts in der CollectionBase-Instanz aus.

(Geerbt von CollectionBase)
OnValidate(Object)

Führt zusätzliche benutzerdefinierte Prozesse beim Validieren eines Werts aus.

(Geerbt von CollectionBase)
Remove(Installer)

Entfernt den angegebenen Installer aus der Auflistung.

RemoveAt(Int32)

Entfernt das Element am angegebenen Index aus der CollectionBase-Instanz. Diese Methode kann nicht überschrieben werden.

(Geerbt von CollectionBase)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

ICollection.CopyTo(Array, Int32)

Kopiert die gesamte CollectionBase-Instanz in ein kompatibles eindimensionales Array, beginnend am angegebenen Index des Zielarrays.

(Geerbt von CollectionBase)
ICollection.IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die CollectionBase synchronisiert (threadsicher) ist.

(Geerbt von CollectionBase)
ICollection.SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf CollectionBase synchronisiert werden kann.

(Geerbt von CollectionBase)
IList.Add(Object)

Fügt am Ende der CollectionBase ein Objekt hinzu.

(Geerbt von CollectionBase)
IList.Contains(Object)

Ermittelt, ob CollectionBase ein bestimmtes Element enthält.

(Geerbt von CollectionBase)
IList.IndexOf(Object)

Sucht nach dem angegebenen Object und gibt den nullbasierten Index des ersten Vorkommens innerhalb der gesamten CollectionBase zurück.

(Geerbt von CollectionBase)
IList.Insert(Int32, Object)

Fügt am angegebenen Index ein Element in die CollectionBase ein.

(Geerbt von CollectionBase)
IList.IsFixedSize

Ruft einen Wert ab, der angibt, ob das CollectionBase eine feste Größe aufweist.

(Geerbt von CollectionBase)
IList.IsReadOnly

Ruft einen Wert ab, der angibt, ob das CollectionBase schreibgeschützt ist.

(Geerbt von CollectionBase)
IList.Item[Int32]

Ruft das Element am angegebenen Index ab oder legt dieses fest.

(Geerbt von CollectionBase)
IList.Remove(Object)

Entfernt das erste Vorkommen eines angegebenen Objekts aus der CollectionBase.

(Geerbt von CollectionBase)

Erweiterungsmethoden

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ um

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.

Gilt für

Siehe auch