Como: Obtenha o andamento da.NET Framework 4 Installer

O .NET Framework versão 4 é um runtime redistribuível. Você pode incluir (cadeia) a .NET Framework 4 o processo de instalação como um componente de pré-requisito na configuração do seu aplicativo. Para apresentar uma experiência de instalação personalizada ou unificado, convém silenciosamente iniciar e controlar o .NET Framework 4 o processo de instalação ao mesmo tempo, mostrando o seu próprio modo de exibição do progresso de instalação. Para ativar o rastreamento silencioso, o .NET Framework 4 o processo de instalação (o chainee, que pode ser visto) pode escrever a mensagem de andamento a um segmento de memória mapeada de e/S (MMIO) que o seu processo de instalação (watcher ou chainer) pode ler. Você pode cancelar a .NET Framework 4 processo de instalação, escrevendo um Abort a mensagem para o segmento MMIO.

1. Invocação. Para chamar o .NET Framework 4 processo de instalação e receber informações sobre o andamento da seção MMIO, seu programa de instalação deve fazer o seguinte:

   1. Chamar o .NET Framework 4 programa redistribuível; Por exemplo:

      dotnetfx40x86.exe /q /pipe <section name>
      

      onde nome da seção é qualquer nome que você deseja usar para identificar o seu aplicativo. O chainee lê e grava a seção MMIO assincronamente, portanto, talvez seja conveniente usar eventos e mensagens durante esse tempo. No exemplo, o chainee é criado por um construtor que ambos aloca a seção MMIO (YourSection) e define um evento (YourEvent). Substitua esses nomes por nomes que são exclusivos para o seu programa de instalação.

   2. Ler a seção MMIO. No .NET Framework 4, as operações de download e instalação são simultâneas: Um componente da .NET Framework 4 pode instalar, enquanto outro está baixando. Como resultado, o progresso é enviado back (isto é, escrito) para a seção MMIO como um número que aumenta de 1 a 255. Quando a 255 é gravado e sai da chainee, a instalação for concluída.

2. Códigos de saída. Os seguintes códigos de saída do comando para chamar o .NET Framework 4 programa redistribuível (veja o exemplo anterior) indicam se a instalação foi bem-sucedida ou falhou:

   • 0 - A instalação foi concluída com êxito.

   • 3010 – Instalação concluída com êxito; é necessário reinicializar.

   • 1642 – A instalação foi cancelada.

   • Todos os códigos - a instalação encontrou erros; Examine os arquivos de log criados em % temp % para obter detalhes.

3. Cancelando a instalação do. Você pode cancelar a instalação a qualquer momento usando o Abort método para definir o m_downloadAbort e m_ installAbort sinalizadores na seção MMIO. Isso interromperá a .NET Framework 4 processo de instalação.

Amostra de chainer

O exemplo a seguir inicia e controla silenciosamente o .NET Framework 4 o processo de instalação ao mesmo tempo, mostrando o andamento.

Cuidado
O exemplo deve ser executado como administrador.

Você pode baixar a solução completa de Visual Studio para o Installer da cadeia para.NET Framework 4 na Galeria de código do Microsoft.

As seções a seguir descrevem os arquivos significativos neste exemplo.

MmIoChainer.h

• O arquivo de MmIoChainer.h contém a definição de estrutura de dados e a classe base da qual a classe chainer deve ser derivada. A estrutura de dados MMIO consiste no seguinte código.

  // MMIO data structure for inter-process communication.
      struct MmioDataStructure
      {
          bool m_downloadFinished;        // Is download done yet?
          bool m_installFinished;         // Is installer operation done yet?
          bool m_downloadAbort;           // Set to cause downloader to abort.
          bool m_installAbort;            // Set to cause installer operation to abort.
          HRESULT m_hrDownloadFinished;   // HRESULT for download.
          HRESULT m_hrInstallFinished;    // HRESULT for installer operation.
          HRESULT m_hrInternalError;      // Internal error from MSI if applicable.
          WCHAR m_szCurrentItemStep[MAX_PATH];   // This identifies the windows installer step being executed if an error occurs while processing an MSI, for example, "Rollback".
          unsigned char m_downloadProgressSoFar; // Download progress 0 - 255 (0 to 100% done). 
          unsigned char m_installProgressSoFar;  // Install progress 0 - 255 (0 to 100% done).
          WCHAR m_szEventName[MAX_PATH];         // Event that chainer creates and chainee opens to sync communications.
      };
  

• Seguindo a estrutura de dados é a estrutura de classe para implementar um chainer. Você derivar de sua classe de servidor da MmioChainer classe para a cadeia de .NET Framework 4 redistribuível. O MmioChainerBase classe é usada, o chainer e chainee. No código a seguir, métodos e membros foram editados para manter o comprimento deste exemplo curto.

  // MmioChainerBase class manages the communication and synchronization data 
      // structures. It also implements common get accessors (for chainer) and set accessors(for chainee).
      class MmioChainerBase
      {
  ...
  
          // This is called by the chainer to force the chained setup to be canceled.
          void Abort()
          {
              //Don't do anything if it is invalid.
              if (NULL == m_pData)
              {
                  return;
              }
  ...
              // Chainer told us to cancel.
              m_pData->m_downloadAbort= true;
              m_pData->m_installAbort = true;
          }
  // Called when chainer wants to know if chained setup has finished both download and installation.
          bool IsDone() const 
          { 
  ...
          }
  
          // Called by the chainer to get the overall progress, i.e., the combination of the download and installation.
          unsigned char GetProgress() const 
          { 
  ...
          }
  
  
          // Get download progress.
          unsigned char GetDownloadProgress() const
          {
  ...
          }
  
          // Get installation progress.
          unsigned char GetInstallProgress() const
          {
  ...
          }
  
          // Get the combined setup result, installation taking priority over download if both failed.
          HRESULT GetResult() const
          { 
  ...
          }
  
  ...
      };
  

• O chainer é implementada da seguinte maneira.

  // This is the class that the consumer (chainer) should derive from.
      class MmioChainer : protected MmioChainerBase
      {
      public:
          // Constructor
          MmioChainer (LPCWSTR sectionName, LPCWSTR eventName)
              : MmioChainerBase(CreateSection(sectionName), CreateEvent(eventName))
          {
              Init(eventName);
          }
  
          // Destructor
          virtual ~MmioChainer ()
          {
              ::CloseHandle(GetEventHandle());
              ::CloseHandle(GetMmioHandle());
          }
  
      public: // The public methods:  Abort and Run
          using MmioChainerBase::Abort;
          using MmioChainerBase::GetInstallResult;
          using MmioChainerBase::GetInstallProgress;
          using MmioChainerBase::GetDownloadResult;
          using MmioChainerBase::GetDownloadProgress;
          using MmioChainerBase::GetCurrentItemStep;
  
          HRESULT GetInternalErrorCode()
          {
              return GetInternalResult();
          }
  
          // Called by the chainer to start the chained setup. This blocks until setup is complete.
          void Run(HANDLE process, IProgressObserver& observer)
          {
              HANDLE handles[2] = { process, GetEventHandle() };
  
              while(!IsDone())
              {
                  DWORD ret = ::WaitForMultipleObjects(2, handles, FALSE, 100); // INFINITE ??
                  switch(ret)
                  {
                  case WAIT_OBJECT_0:
                      { // Process handle closed.  Maybe it blew up, maybe it's just really fast.  Let's find out.
                          if (IsDone() == false) // Not a good sign
                          {
                              HRESULT hr = GetResult();
                              if (hr == E_PENDING) // Untouched
                                  observer.Finished(E_FAIL);
                              else
                                  observer.Finished(hr);
  
                              return;
                          }
                          break;
                      }
                  case WAIT_OBJECT_0 + 1:
                      observer.OnProgress(GetProgress());
                      break;
                  default:
                      break;
                  }
              }
              observer.Finished(GetResult());
          }
  
      private:
          static HANDLE CreateSection(LPCWSTR sectionName)
          {
              return ::CreateFileMapping (INVALID_HANDLE_VALUE,
                  NULL, // Security attributes
                  PAGE_READWRITE,
                  0, // high-order DWORD of maximum size
                  sizeof(MmioDataStructure), // Low-order DWORD of maximum size.
                  sectionName);
          }
          static HANDLE CreateEvent(LPCWSTR eventName)
          {
              return ::CreateEvent(NULL, FALSE, FALSE, eventName);
          }
      };
  

• O chainee deriva da mesma classe base.

  // This class is used by the chainee.
      class MmioChainee : protected MmioChainerBase
      {
      public:
          MmioChainee(LPCWSTR sectionName)
              : MmioChainerBase(OpenSection(sectionName), OpenEvent(GetEventName(sectionName)))
          {
          }
  
          virtual ~MmioChainee()
          {
          }
  
      private:
          static HANDLE OpenSection(LPCWSTR sectionName)
          {
              return ::OpenFileMapping(FILE_MAP_WRITE, // Read/write access.
                  FALSE,          // Do not inherit the name.
                  sectionName);
          }
  
          static HANDLE OpenEvent(LPCWSTR eventName)
          {        
              return ::OpenEvent (EVENT_MODIFY_STATE | SYNCHRONIZE,
                  FALSE,
                  eventName);
          }
  
          static CString GetEventName(LPCWSTR sectionName)
          {
              CString cs = L"";
  
              HANDLE handle = OpenSection(sectionName);
              if (NULL == handle)
              {
                  DWORD dw;
                  dw = GetLastError();
                  printf("OpenFileMapping fails with last error: %08x",dw);
              }
              else
              {
                  const MmioDataStructure* pData = MapView(handle);
                  if (pData)
                  {
                      cs = pData->m_szEventName;
                      ::UnmapViewOfFile(pData);
                  }
                  ::CloseHandle(handle);
              }
  
              return cs;
          }
      };
  

ChainingdotNet4.cpp

• Você pode derivar a partir de MmioChainer de classe e substituir os métodos apropriados para exibir informações de progresso. Observe que MmioChainer já oferece um bloqueio de Run() método que a classe derivada será chamada. O Server classe no código a seguir inicia o programa de instalação especificado, monitora o seu progresso e retorna um código de saída.

  class Server : public ChainerSample::MmioChainer, public ChainerSample::IProgressObserver
  {
  public:
      // Mmiochainer will create section with given name. Create this section and the event name.
      // Event is also created by the Mmiochainer, and name is saved in the mapped data structure.
      Server():ChainerSample::MmioChainer(L"TheSectionName", L"TheEventName")
   // Customize for your event names.
      {}
  
      bool Launch(const CString& args)
      {
          CString cmdline = L"Setup.exe -pipe TheSectionName " + args; // Customize with name and location of setup .exe file that you want to run.
          STARTUPINFO si = {0};
          si.cb = sizeof(si);
          PROCESS_INFORMATION pi = {0};
  
          // Launch the Setup.exe that installs the .NET Framework 4.
          BOOL bLaunchedSetup = ::CreateProcess(NULL, 
                                   cmdline.GetBuffer(),
                                   NULL, NULL, FALSE, 0, NULL, NULL, 
                                   &si,
                                   &pi);
  
          // If successful 
          if (bLaunchedSetup != 0)
          {
              IProgressObserver& observer = dynamic_cast<IProgressObserver&>(*this);
              Run(pi.hProcess, observer);
  
              // To get the return code of the chainee, check exit code
              // of the chainee process after it exits.
              DWORD exitCode = 0;
  
              // Get the true return code.
              ::GetExitCodeProcess(pi.hProcess, &exitCode);
              printf("Exit code: %08X\n  ", exitCode);
  
              // Get internal result.
              // If the failure is in an MSI/MSP payload, the internal result refers to the error messages listed at
              // https://msdn.microsoft.com/en-us/library/aa372835(VS.85).aspx
              HRESULT hrInternalResult = GetInternalResult(); 
              printf("Internal result: %08X\n",hrInternalResult);
  
  
  
  
              ::CloseHandle(pi.hThread);
              ::CloseHandle(pi.hProcess);
          }
          else
          {
              printf("CreateProcess failed");
              ReportLastError();
          }
  
          return (bLaunchedSetup != 0);
      }
  
  private: // IProgressObserver
      virtual void OnProgress(unsigned char ubProgressSoFar)
      {
          printf("Progress: %i\n  ", ubProgressSoFar);
  
          // Testing: BEGIN - To test Abort behavior, uncomment the following code:
          //if (ubProgressSoFar > 127)
          //{
          //    printf("\rDeliberately Aborting with progress at %i  ", ubProgressSoFar);
          //    Abort();
          //}
          // Testing END
      }
  
      virtual void Finished(HRESULT hr)
      {
          // This HRESULT is communicated over MMIO and may be different from process
          // exit code of the chainee Setup.exe.
          printf("\r\nFinished HRESULT: 0x%08X\r\n", hr);
      }
  ...
  };
  

  Dados de andamento será um unsigned char entre 0 (% 0) e 255 (100%). A saída de Finished método é um HRESULT.

  Observação

  O .NET Framework 4 redistribuível normalmente grava muitas mensagens de progresso e uma única mensagem que indica a conclusão (no lado chainer).Ele também lê assincronamente, procurando por Abort registros.Se receber um Abort registro, ele cancela a instalação e (eventualmente) grava um registro concluído com E_ABORT como dados.

  Cria um nome de arquivo MMIO aleatório de um servidor típico, cria o arquivo (como mostrado no exemplo de código anterior, na Server::CreateSection) e inicia o redistribuível usando CreateProcess, passando o nome do pipe com o "-pipe someFileSectionName" switch. O servidor OnProgress e Finished métodos contêm código de servidor específicas.

IprogressObserver.h

• O observador de progresso é notificado de progresso (0-255) e a instalação for concluída.

  #ifndef IPROGRESSOBSERVER_H
  #define IPROGRESSOBSERVER_H
  
  #include <oaidl.h>
  
  namespace ChainerSample
  {
      class IProgressObserver
      {
      public:
          virtual void OnProgress(unsigned char) = 0; // 0 - 255:  255 == 100%
          virtual void Finished(HRESULT) = 0;         // Called when operation is complete.
      };
  }
  #endif
  

• O HRESULT é passado para o Finished método.O código a seguir mostra o ponto de entrada principal para o programa.

  // Main entry point for program.
  int __cdecl main(int argc, _In_count_(argc) char **_argv)
  {
      CString args;
      if (argc > 1)
      {
          args = CString(_argv[1]);
      }
  
      return Server().Launch(args);
  }
  

• Altere o caminho do executável (Setup. exe no exemplo) para apontar para o local correto ou altere o código para descobrir. Você deve executar o código como um administrador.

Consulte também

Conceitos

Implantando o.NET Framework e aplicativos

Outros recursos

.Guia de implantação do NET Framework para desenvolvedores

Histórico de alterações

Date	History	Motivo
Julho de 2010	Tópico adicional.	Aprimoramento de informações.