InstallerCollection Classe

Definizione

Spazio dei nomi:: System.Configuration.Install

Assembly:: System.Configuration.Install.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Contiene una raccolta di programmi di installazione da eseguire durante un'installazione.

public ref class InstallerCollection : System::Collections::CollectionBase

public class InstallerCollection : System.Collections.CollectionBase

type InstallerCollection = class
    inherit CollectionBase

Public Class InstallerCollection
Inherits CollectionBase

Ereditarietà: Object

CollectionBase
InstallerCollection

Esempio

Nell'esempio seguente viene illustrato il Add metodo della InstallerCollection classe . Questo esempio fornisce un'implementazione simile a quella di Installutil.exe (strumento di installazione). Vengono installati assembly con le opzioni precedenti a quel particolare assembly. Se non viene specificata un'opzione per un assembly, vengono prese le opzioni dell'assembly precedente se è presente un assembly precedente nell'elenco. Se viene specificata l'opzione "/u" o "/uninstall", gli assembly vengono disinstallati. Se viene fornita l'opzione "/?" o "/help", le informazioni della Guida vengono visualizzate nella 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

Commenti

InstallerCollection fornisce i metodi e le proprietà necessari all'applicazione per gestire una raccolta di Installer oggetti.

Utilizzare uno dei tre modi seguenti per aggiungere programmi di installazione alla raccolta:

Il Add metodo aggiunge un singolo programma di installazione alla raccolta.
I AddRange metodi aggiungono più programmi di installazione alla raccolta.
Il Insert metodo e la Item[] proprietà , ovvero l'indicizzatore InstallerCollection , aggiungono un singolo programma di installazione alla raccolta in corrispondenza dell'indice specificato.

Rimuovere i programmi di installazione tramite il Remove metodo . Verificare se un programma di installazione si trova nella raccolta usando il Contains metodo . Trovare dove si trova un programma di installazione nella raccolta usando il IndexOf metodo .

I programmi di installazione in una raccolta vengono eseguiti quando il programma di installazione contenente la raccolta, come specificato dalla Installer.Parent proprietà , chiama i Installrelativi metodi , Commit, Rollbacko Uninstall .

Per esempi di utilizzo di una raccolta di programmi di installazione, vedere le AssemblyInstaller classi e TransactedInstaller .

Proprietà

Nome	Descrizione
Capacity	Ottiene o imposta il numero di elementi che l'oggetto CollectionBase può contenere. (Ereditato da CollectionBase)
Count	Ottiene il numero di elementi contenuti nell'istanza CollectionBase di . Impossibile eseguire l'override di questa proprietà. (Ereditato da CollectionBase)
InnerList	Ottiene un oggetto ArrayList contenente l'elenco di elementi nell'istanza CollectionBase di . (Ereditato da CollectionBase)
Item[Int32]	Ottiene o imposta un programma di installazione in corrispondenza dell'indice specificato.
List	Ottiene un oggetto IList contenente l'elenco di elementi nell'istanza CollectionBase di . (Ereditato da CollectionBase)

Metodi

Nome	Descrizione
Add(Installer)	Aggiunge il programma di installazione specificato a questa raccolta di programmi di installazione.
AddRange(Installer[])	Aggiunge la matrice specificata di programmi di installazione a questa raccolta.
AddRange(InstallerCollection)	Aggiunge la raccolta specificata di programmi di installazione a questa raccolta.
Clear()	Rimuove tutti gli oggetti dall'istanza CollectionBase di . Non è possibile eseguire l'override di questo metodo. (Ereditato da CollectionBase)
Contains(Installer)	Determina se il programma di installazione specificato è incluso nella raccolta.
CopyTo(Installer[], Int32)	Copia gli elementi dall'insieme in una matrice, a partire dall'indice specificato.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetEnumerator()	Restituisce un enumeratore che scorre l'istanza CollectionBase di . (Ereditato da CollectionBase)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
IndexOf(Installer)	Determina l'indice di un programma di installazione specificato nella raccolta.
Insert(Int32, Installer)	Inserisce il programma di installazione specificato nella raccolta in corrispondenza dell'indice specificato.
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
OnClear()	Esegue processi personalizzati aggiuntivi quando si cancella il contenuto dell'istanza CollectionBase . (Ereditato da CollectionBase)
OnClearComplete()	Esegue processi personalizzati aggiuntivi dopo la cancellazione del contenuto dell'istanza CollectionBase . (Ereditato da CollectionBase)
OnInsert(Int32, Object)	Esegue processi personalizzati aggiuntivi prima dell'inserimento di un nuovo programma di installazione nella raccolta.
OnInsertComplete(Int32, Object)	Esegue processi personalizzati aggiuntivi dopo l'inserimento di un nuovo elemento nell'istanza CollectionBase di . (Ereditato da CollectionBase)
OnRemove(Int32, Object)	Esegue processi personalizzati aggiuntivi prima che un programma di installazione venga rimosso dalla raccolta.
OnRemoveComplete(Int32, Object)	Esegue processi personalizzati aggiuntivi dopo la rimozione di un elemento dall'istanza CollectionBase di . (Ereditato da CollectionBase)
OnSet(Int32, Object, Object)	Esegue processi personalizzati aggiuntivi prima che un programma di installazione esistente sia impostato su un nuovo valore.
OnSetComplete(Int32, Object, Object)	Esegue processi personalizzati aggiuntivi dopo aver impostato un valore nell'istanza CollectionBase di . (Ereditato da CollectionBase)
OnValidate(Object)	Esegue processi personalizzati aggiuntivi durante la convalida di un valore. (Ereditato da CollectionBase)
Remove(Installer)	Rimuove l'oggetto specificato Installer dalla raccolta.
RemoveAt(Int32)	Rimuove l'elemento in corrispondenza dell'indice specificato dell'istanza CollectionBase . Questo metodo non è sostituibile. (Ereditato da CollectionBase)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

Nome	Descrizione
ICollection.CopyTo(Array, Int32)	Copia l'intero CollectionBase oggetto in un oggetto unidimensionale Arraycompatibile, a partire dall'indice specificato della matrice di destinazione. (Ereditato da CollectionBase)
ICollection.IsSynchronized	Ottiene un valore che indica se l'accesso CollectionBase a è sincronizzato (thread-safe). (Ereditato da CollectionBase)
ICollection.SyncRoot	Ottiene un oggetto che può essere utilizzato per sincronizzare l'accesso all'oggetto CollectionBase. (Ereditato da CollectionBase)
IList.Add(Object)	Aggiunge un oggetto alla fine dell'oggetto CollectionBase. (Ereditato da CollectionBase)
IList.Contains(Object)	Determina se contiene CollectionBase un elemento specifico. (Ereditato da CollectionBase)
IList.IndexOf(Object)	Cerca l'oggetto specificato Object e restituisce l'indice in base zero della prima occorrenza all'interno dell'intero CollectionBaseoggetto . (Ereditato da CollectionBase)
IList.Insert(Int32, Object)	Inserisce un elemento nell'oggetto CollectionBase in corrispondenza dell'indice specificato. (Ereditato da CollectionBase)
IList.IsFixedSize	Ottiene un valore che indica se ha CollectionBase una dimensione fissa. (Ereditato da CollectionBase)
IList.IsReadOnly	Ottiene un valore che indica se l'oggetto CollectionBase è di sola lettura. (Ereditato da CollectionBase)
IList.Item[Int32]	Ottiene o imposta l'elemento in corrispondenza dell'indice specificato. (Ereditato da CollectionBase)
IList.Remove(Object)	Rimuove la prima occorrenza di un oggetto specifico da CollectionBase. (Ereditato da CollectionBase)

Metodi di estensione

Nome	Descrizione
AsParallel(IEnumerable)	Abilita la parallelizzazione di una query.
AsQueryable(IEnumerable)	Converte un IEnumerable in un IQueryable.
Cast<TResult>(IEnumerable)	Esegue il cast degli elementi di un IEnumerable al tipo specificato.
OfType<TResult>(IEnumerable)	Filtra gli elementi di un IEnumerable in base a un tipo specificato.

Si applica a

Vedi anche

Commenti e suggerimenti

Questa pagina è stata utile?