Como: Obtenha o andamento da.NET Framework 4 Installer

Artigo
08/01/2011

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.

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.
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.
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.

Julho de 2010

Tópico adicional.

Aprimoramento de informações.

Compartilhar via