InstallerCollection InstallerCollection InstallerCollection InstallerCollection Class

Definição

Contém uma coleção de instaladores a ser executada durante a instalação.Contains a collection of installers to be run during an installation.

public ref class InstallerCollection : System::Collections::CollectionBase
public class InstallerCollection : System.Collections.CollectionBase
type InstallerCollection = class
    inherit CollectionBase
Public Class InstallerCollection
Inherits CollectionBase
Herança
InstallerCollectionInstallerCollectionInstallerCollectionInstallerCollection

Exemplos

O exemplo a seguir demonstra Add o método InstallerCollection da classe.The following example demonstrates the Add method of the InstallerCollection class. Este exemplo fornece uma implementação semelhante à do InstallUtil. exe (ferramenta de instalação).This example provides an implementation similar to that of Installutil.exe (Installer Tool). Ele instala assemblies com as opções anteriores a esse assembly específico.It installs assemblies with the options preceding that particular assembly. Se uma opção não for especificada para um assembly, as opções do assembly anterior serão tomadas se houver um assembly anterior na lista.If an option is not specified for an assembly, the previous assembly's options are taken if there is a previous assembly in the list. Se a opção "/u" ou "/uninstall" for especificada, os assemblies serão desinstalados.If the "/u" or "/uninstall" option is specified, the assemblies are uninstalled. Se o "/?"If the "/?" ou a opção "/Help" é fornecida, as informações de ajuda são exibidas para o console.or "/help" option is provided, the help information is displayed to the console.

#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

Comentários

O InstallerCollection fornece os métodos e propriedades que seu aplicativo precisa para gerenciar uma coleção de Installer objetos.The InstallerCollection provides the methods and properties that your application needs to manage a collection of Installer objects.

Use qualquer uma das três maneiras a seguir para adicionar instaladores à coleção:Use any of the following three ways to add installers to the collection:

  • O Add método adiciona um único instalador à coleção.The Add method adds a single installer to the collection.

  • Os AddRange métodos adicionam vários instaladores à coleção.The AddRange methods add multiple installers to the collection.

  • O Insert método e a Item[Int32] Propriedade, que é o InstallerCollection indexador, cada um adiciona um único instalador à coleção no índice especificado.The Insert method and the Item[Int32] property, which is the InstallerCollection indexer, each add a single installer to the collection at the specified index.

Remova os instaladores por Remove meio do método.Remove installers through the Remove method. Verifique se um instalador está na coleção usando o Contains método.Check whether an installer is in the collection by using the Contains method. Localize o local em que um instalador está localizado na coleção usando IndexOf o método.Find where an installer is located in the collection by using the IndexOf method.

Os instaladores em uma coleção são executados quando o instalador que contém a coleção, conforme especificado pela Installer.Parent Propriedade, chama seus Installmétodos Commit, Rollback, ou Uninstall .The installers in a collection are run when the installer containing the collection, as specified by the Installer.Parent property, calls their Install, Commit, Rollback, or Uninstall methods.

Para obter exemplos de uso de uma coleção de instalador, consulte AssemblyInstaller as TransactedInstaller classes e.For examples of the usage of an installer collection, see the AssemblyInstaller and TransactedInstaller classes.

Propriedades

Capacity Capacity Capacity Capacity

Obtém ou define o número de elementos que o CollectionBase pode conter.Gets or sets the number of elements that the CollectionBase can contain.

(Inherited from CollectionBase)
Count Count Count Count

Obtém o número de elementos contidos na instância CollectionBase.Gets the number of elements contained in the CollectionBase instance. Essa propriedade não pode ser substituída.This property cannot be overridden.

(Inherited from CollectionBase)
ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized

Obtém um valor que indica se o acesso à CollectionBase é sincronizado (thread-safe).Gets a value indicating whether access to the CollectionBase is synchronized (thread safe).

(Inherited from CollectionBase)
ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso ao CollectionBase.Gets an object that can be used to synchronize access to the CollectionBase.

(Inherited from CollectionBase)
IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize

Obtém um valor que indica se o CollectionBase tem um tamanho fixo.Gets a value indicating whether the CollectionBase has a fixed size.

(Inherited from CollectionBase)
IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly

Obtém um valor que indica se o CollectionBase é somente leitura.Gets a value indicating whether the CollectionBase is read-only.

(Inherited from CollectionBase)
IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] IList.Item[Int32]

Obtém ou define o elemento no índice especificado.Gets or sets the element at the specified index.

(Inherited from CollectionBase)
InnerList InnerList InnerList InnerList

Obtém uma ArrayList que contém a lista de elementos na instância de CollectionBase.Gets an ArrayList containing the list of elements in the CollectionBase instance.

(Inherited from CollectionBase)
Item[Int32] Item[Int32] Item[Int32] Item[Int32]

Obtém ou define um instalador no índice especificado.Gets or sets an installer at the specified index.

List List List List

Obtém uma IList que contém a lista de elementos na instância de CollectionBase.Gets an IList containing the list of elements in the CollectionBase instance.

(Inherited from CollectionBase)

Métodos

Add(Installer) Add(Installer) Add(Installer) Add(Installer)

Adiciona o instalador especificado a esta coleção de instaladores.Adds the specified installer to this collection of installers.

AddRange(InstallerCollection) AddRange(InstallerCollection) AddRange(InstallerCollection) AddRange(InstallerCollection)

Adiciona a coleção de instaladores especificada a essa coleção.Adds the specified collection of installers to this collection.

AddRange(Installer[]) AddRange(Installer[]) AddRange(Installer[]) AddRange(Installer[])

Adiciona a matriz especificada de instaladores para essa coleção.Adds the specified array of installers to this collection.

Clear() Clear() Clear() Clear()

Remove todos os objetos da instância CollectionBase.Removes all objects from the CollectionBase instance. Esse método não pode ser substituído.This method cannot be overridden.

(Inherited from CollectionBase)
Contains(Installer) Contains(Installer) Contains(Installer) Contains(Installer)

Determina se o instalador especificado está incluído na coleção.Determines whether the specified installer is included in collection.

CopyTo(Installer[], Int32) CopyTo(Installer[], Int32) CopyTo(Installer[], Int32) CopyTo(Installer[], Int32)

Copia os itens da coleção para uma matriz, começando no índice especificado.Copies the items from the collection to an array, beginning at the specified index.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Retorna um enumerador que itera pela instância CollectionBase.Returns an enumerator that iterates through the CollectionBase instance.

(Inherited from CollectionBase)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
IndexOf(Installer) IndexOf(Installer) IndexOf(Installer) IndexOf(Installer)

Determina o índice de um instalador especificado na coleção.Determines the index of a specified installer in the collection.

Insert(Int32, Installer) Insert(Int32, Installer) Insert(Int32, Installer) Insert(Int32, Installer)

Insere o instalador especificado na coleção no índice especificado.Inserts the specified installer into the collection at the specified index.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
OnClear() OnClear() OnClear() OnClear()

Executa processos personalizados adicionais ao limpar o conteúdo da instância CollectionBase.Performs additional custom processes when clearing the contents of the CollectionBase instance.

(Inherited from CollectionBase)
OnClearComplete() OnClearComplete() OnClearComplete() OnClearComplete()

Executa processos adicionais personalizados após limpar o conteúdo da instância CollectionBase.Performs additional custom processes after clearing the contents of the CollectionBase instance.

(Inherited from CollectionBase)
OnInsert(Int32, Object) OnInsert(Int32, Object) OnInsert(Int32, Object) OnInsert(Int32, Object)

Executa processos personalizados adicionais antes que um novo instalador seja inserido na coleção.Performs additional custom processes before a new installer is inserted into the collection.

OnInsertComplete(Int32, Object) OnInsertComplete(Int32, Object) OnInsertComplete(Int32, Object) OnInsertComplete(Int32, Object)

Executa processos personalizados adicionais após inserir um novo elemento na instância de CollectionBase.Performs additional custom processes after inserting a new element into the CollectionBase instance.

(Inherited from CollectionBase)
OnRemove(Int32, Object) OnRemove(Int32, Object) OnRemove(Int32, Object) OnRemove(Int32, Object)

Executa processos personalizados adicionais antes que um instalador seja removido na coleção.Performs additional custom processes before an installer is removed from the collection.

OnRemoveComplete(Int32, Object) OnRemoveComplete(Int32, Object) OnRemoveComplete(Int32, Object) OnRemoveComplete(Int32, Object)

Executa processos personalizados adicionais após remover um elemento da instância de CollectionBase.Performs additional custom processes after removing an element from the CollectionBase instance.

(Inherited from CollectionBase)
OnSet(Int32, Object, Object) OnSet(Int32, Object, Object) OnSet(Int32, Object, Object) OnSet(Int32, Object, Object)

Executa processos personalizados adicionais antes que um instalador existente seja definido como um novo valor.Performs additional custom processes before an existing installer is set to a new value.

OnSetComplete(Int32, Object, Object) OnSetComplete(Int32, Object, Object) OnSetComplete(Int32, Object, Object) OnSetComplete(Int32, Object, Object)

Executa processos personalizados adicionais após configurar um valor na instância de CollectionBase.Performs additional custom processes after setting a value in the CollectionBase instance.

(Inherited from CollectionBase)
OnValidate(Object) OnValidate(Object) OnValidate(Object) OnValidate(Object)

Executa processos personalizados adicionais ao validar um valor.Performs additional custom processes when validating a value.

(Inherited from CollectionBase)
Remove(Installer) Remove(Installer) Remove(Installer) Remove(Installer)

Remove o Installer especificado da coleção.Removes the specified Installer from the collection.

RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32)

Remove o elemento no índice especificado da instância CollectionBase.Removes the element at the specified index of the CollectionBase instance. Este método não é substituível.This method is not overridable.

(Inherited from CollectionBase)
ToString() ToString() ToString() ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)

Implantações explícitas de interface

ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32)

Copia todo o CollectionBase em um Array unidimensional compatível, começando no índice especificado da matriz de destino.Copies the entire CollectionBase to a compatible one-dimensional Array, starting at the specified index of the target array.

(Inherited from CollectionBase)
IList.Add(Object) IList.Add(Object) IList.Add(Object) IList.Add(Object)

Adiciona um objeto ao final do CollectionBase.Adds an object to the end of the CollectionBase.

(Inherited from CollectionBase)
IList.Contains(Object) IList.Contains(Object) IList.Contains(Object) IList.Contains(Object)

Determina se o CollectionBase contém um elemento específico.Determines whether the CollectionBase contains a specific element.

(Inherited from CollectionBase)
IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object)

Pesquisa o Object especificado e retorna o índice de base zero da primeira ocorrência dentro de todo o CollectionBase.Searches for the specified Object and returns the zero-based index of the first occurrence within the entire CollectionBase.

(Inherited from CollectionBase)
IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object)

Insere um elemento no CollectionBase, no índice especificado.Inserts an element into the CollectionBase at the specified index.

(Inherited from CollectionBase)
IList.Remove(Object) IList.Remove(Object) IList.Remove(Object) IList.Remove(Object)

Remove a primeira ocorrência de um objeto específico do CollectionBase.Removes the first occurrence of a specific object from the CollectionBase.

(Inherited from CollectionBase)

Métodos de Extensão

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

Aplica-se a

Veja também