Geralmente, existem dois métodos de atualização do aplicativo: um é notificar o usuário (como enviar um e-mail) e solicitar que o usuário baixe o programa atualizado de um endereço de site designado; o outro é transferir a responsabilidade de atualização do usuário para o; próprio aplicativo, em vez de o usuário obter e instalar uma atualização de software, o próprio aplicativo cliente é responsável por baixar e instalar atualizações de um servidor conhecido. A única intervenção que o usuário precisa fazer é decidir se deseja instalar novas atualizações agora ou. mais tarde. Obviamente, o último é mais amigável que o primeiro. Agora você pode ver produtos reais que se assemelham à última abordagem, como o Windows XP e o Microsoft Money. O componente de atualização de aplicativo .NET apresentado neste artigo pode fornecer funcionalidade semelhante.
1. Introdução ao componente de atualização de aplicativos .NET
O componente de atualização de aplicativos .NET AppUpdater é desenvolvido usando o framework .NET. Embora o AppUpdater não seja um produto da Microsoft, contanto que você adicione o componente à barra de ferramentas do VS.NET, você pode arrastar e soltar o componente da barra de ferramentas em seu aplicativo, assim como usar outros componentes. e frequência de obtenção de atualizações, etc.), sua aplicação cliente pode ter a função de atualização automática.
2. Princípio de funcionamento
Para compreender profundamente o princípio de funcionamento do componente de atualização do aplicativo cliente .NET, você precisa estudar cuidadosamente o que deve ser feito para implementar a atualização do aplicativo cliente. O primeiro passo é verificar se há uma atualização; quando uma atualização for encontrada, inicie a segunda etapa - baixe a atualização quando o download da atualização for concluído, prossiga para a última etapa - implemente a atualização;
(1) Verifique se há atualizações
Como desenvolvedor, você deve primeiro informar ao aplicativo onde procurar atualizações. Caso contrário, não seria como procurar uma agulha em um palheiro? Segundo, determine quando verificar atualizações. É impossível para o usuário executar o programa cliente todas as vezes e ele verifica constantemente se há atualizações em segundo plano. Que desperdício de recursos! Uma última coisa importante a abordar é como verificar se há atualizações. O componente .NET Application Update usa HTTP para comunicação, o que permite que aplicativos clientes executem atualizações por meio de firewalls. E o endereço necessário para verificação de atualização torna-se um endereço URL de um servidor web conhecido, e o primeiro problema é resolvido com sucesso.
O componente de atualização da aplicação .NET gera um thread baseado na geração do componente, que é responsável pela verificação de atualizações. Este thread fica suspenso na maior parte do tempo, mas acorda em intervalos definidos e executa uma verificação de atualização. A frequência com que um aplicativo verifica novas atualizações depende do aplicativo. Os valores comuns para o intervalo entre verificações de atualização normalmente variam de uma hora a vários dias. Esta abordagem básica à votação não é adequada para todas as situações. Por exemplo, o Microsoft Money só verifica atualizações quando o usuário solicita. Nesse caso, o thread de pesquisa de atualização pode ser desativado.
A verificação de atualização é implementada chamando o método CheckForUpdate() do componente de atualização com um comando.
Existem vários métodos para realizar verificações de atualização:
Método 1: Verificação direta de arquivos - Use HTTP para comparar o carimbo de data/hora da última modificação do servidor e dos aplicativos cliente para ver se eles são consistentes. Se houver um arquivo atualizado no servidor, o cliente sabe que ele pode se atualizar. O mesmo se aplica a um navegador da Web, que sabe se precisa baixar novamente uma página ou imagem HTML ou se pode reutilizar uma página baixada anteriormente. Quando uma nova versão do aplicativo fica disponível, o administrador simplesmente copia a versão mais recente sobre a versão mais antiga no servidor Web. O problema com esta abordagem é que a atualização não é automática, portanto existe um potencial de falha. Por exemplo, se um administrador estiver atualizando a versão de um aplicativo em um servidor Web e um cliente estiver baixando uma versão antes da atualização, o computador do cliente terá alguns arquivos anteriores à atualização, bem como alguns arquivos da nova versão. versão após o documento de atualização. Pelas razões acima, a verificação direta de atualizações em arquivos não é recomendada para aplicativos críticos.
Método 2: Verificação explícita - use um arquivo de configuração explícito no servidor. Um arquivo explícito de servidor válido para uso com componentes de atualização de aplicativos .NET se parece com isto: ..
<VersionConfig>
＜Versão disponível＞1.0.0.0＜/Versão disponível＞
＜ApplicationUrl＞ http://localhost/demos/selfupdate/V1/ ＜/
URL do aplicativo＞
</VersionConfig>
AvailableVersion especifica o número da versão do assembly disponível mais recente. O atributo ApplicationURL especifica o endereço URL onde esta versão do aplicativo está localizada. Quando os administradores desejam atualizar um aplicativo cliente, eles copiam a nova versão do aplicativo para o servidor Web e modificam os arquivos explícitos do servidor adequadamente. O próprio cliente detectará que o arquivo explícito do servidor foi modificado e, em seguida, fará o download do arquivo explícito. O cliente então compara o número da versão do assembly especificado no arquivo explícito com o número da versão do arquivo EXE do aplicativo. Se um número de versão mais recente estiver disponível no arquivo explícito do servidor, o aplicativo saberá que ele precisa ser atualizado. Este método é recomendado para a maioria das aplicações.
Método três: Verificação do XML Web Service - XML WebServices fornece um método de verificação de atualização mais avançado. Por exemplo, suponha que você queira atualizar um conjunto de usuários anteriores antes de atualizar seus outros usuários. Se o aplicativo cliente chamar um XML Web Service para verificar se uma atualização está disponível, esse XML Web Service também poderá consultar o banco de dados para obter essa atualização. e determinar se o usuário é um usuário inicial. Se forem usuários antigos, o XML Web Service retornará um valor indicando que há atualizações disponíveis. Caso contrário, o Web Service retornará um valor indicando que a atualização não está disponível. No entanto, o componente de atualização de aplicativo .NET apresentado neste artigo não fornece suporte direto ao XML Web Service.
Para usar o XML Web Service para realizar verificações de atualização, primeiro crie um XML Web Service e conecte um evento OnCheckForUpdate. Isso permite que você escreva suas próprias verificações personalizadas no lugar das verificações de atualização do thread do poller. O evento OnCheckForUpdate possui um valor de retorno que indica se uma atualização foi detectada.
(2) Baixar atualizações
Quando o componente de atualização do aplicativo .NET detecta que uma nova atualização está disponível, ele iniciará automaticamente outro thread e iniciará o download assíncrono de atualizações em segundo plano.
O download é feito usando HTTP-DAV. DAV é uma versão estendida do HTTP, que fornece funcionalidades como enumeração de diretórios e arquivos. Um processo completo de download começa especificando um URL. O URL usado para download depende do método usado para concluir a verificação de atualização. Por exemplo, se você usar arquivos explícitos do servidor, a URL usada para fazer download de atualizações será especificada por meio do atributo ApplicationURL no arquivo explícito do servidor.
O download da atualização obviamente requer alguma robustez. É inaceitável deixar um aplicativo cliente em qualquer estado instável após o download e a atualização. Vários problemas podem ocorrer durante o processo de download: o servidor web ao qual pertence o arquivo de atualização pode estar inativo, a máquina cliente pode travar ou o usuário pode simplesmente fechar o aplicativo por algum motivo. Como o download do aplicativo está em andamento, se ele for fechado, o download será interrompido. Uma solução alternativa de design é usar serviços de sistema separados para downloads e atualizações de aplicativos. Usando os serviços do sistema, os downloads de atualizações continuam mesmo quando o próprio aplicativo não está em execução. Na verdade, o Windows XP possui um serviço de download integrado chamado BITS, que atende a esse propósito. O BITS é usado pelo Windows XP para baixar e atualizar o próprio Windows. Para obter mais informações sobre o BITS, consulte http://msdn.microsoft.com/library/en-us/dnwxp/html/WinXP_BITS.asp . Este serviço não é usado no componente .NET Application Update, portanto pode ser usado no Windows 9x que não oferece suporte a serviços do sistema.
(3) Implementando Atualizações
O componente de atualização de aplicações .NET ganha robustez ao dividir os processos de download e atualização em duas fases distintas. Quando cada etapa for concluída, ela será registrada em um arquivo de manifesto atualizado localizado no diretório do aplicativo cliente. Se o processo de download ou atualização for interrompido em qualquer estágio, ele retomará o trabalho original a partir do último ponto de interrupção concluído na próxima vez que o aplicativo for iniciado. Cada estágio pode ser executado novamente, portanto, se ocorrer uma falha no meio de um estágio, a repetição do estágio será bem-sucedida. Se ocorrer um erro, como a perda da conexão com o servidor durante o download, o componente de atualização do .NET tentará novamente mais tarde. Se muitos erros forem relatados (por exemplo, o servidor web nunca mais voltar a ficar online), os downloads e as atualizações serão abortados e os erros serão relatados.
Nossa primeira abordagem é simplesmente iniciar um processo separado para implementar a atualização. Este processo separado primeiro encerrará o processo de inscrição, implementará a atualização (uma vez que agora está desbloqueado), reiniciará o processo de inscrição e, em seguida, encerrará automaticamente quando terminar. Portanto, existem três problemas básicos com este design:
Em alguns casos ele não funciona. Quando um aplicativo é atualizado, o processo de atualização fecha o processo do aplicativo original e o próprio processo de atualização também é fechado, portanto a atualização não será implementada.
Queremos poder atualizar automaticamente todo o código que precisa ser atualizado. Queremos a capacidade de instalar patches automaticamente não apenas no aplicativo, mas também no próprio componente .NET Application Update. Usando este modo, não podemos atualizar o processo que implementa a atualização.
.É rude forçar o usuário a fechar o aplicativo e esperar enquanto o usa.
O método final usado para implementar atualizações de aplicativos é usar o padrão de montagem paralela do .NET Framework. Como alternativa a tentar atualizar o próprio aplicativo, gere uma versão mais recente do aplicativo do que a versão existente atualmente.
Novas versões podem ser geradas mesclando o catálogo de aplicativos existente com versões atualizadas baixadas. Quando a nova versão for concluída, o usuário usará automaticamente a nova versão na próxima vez que reabrir o aplicativo. A cópia do aplicativo original pode então ser removida. O complicado é descobrir qual versão deve ser carregada em um determinado momento. Apresentamos um aplicativo chamado Appstart. Appstart é o ponto de entrada em seu aplicativo. Usando este modo, o diretório do seu aplicativo se parece com isto: ..
--> Arquivos de Programas
--> MyApp
--> Appstart.exe
--> Appstart.config
--> Pasta V1
--> > MyApp.exe
--> Pasta V1.1
--> MyApp.exe
Para executar seu aplicativo, você normalmente inicia Appstart.exe. Se você deseja ter uma tecla de atalho na área de trabalho, essa tecla de atalho deve apontar para Appstart e não diretamente para o aplicativo (observe que você pode renomear AppStart.exe para o que quiser, como YourApp.exe) Appstart.exe É um programa muito simples que lê o arquivo Appstart.config e carrega o aplicativo especificado. Um arquivo Appstart.config válido se parece com isto:
<Config>
＜AppFolderName＞Pasta V1＜/AppFolderName＞
＜AppExeName＞MyApp.exe＜/AppExeName＞
＜AppLaunchMode＞appdomain＜/AppLaunchMode＞
＜/Configuração＞
AppFolderName especifica a subpasta que contém a versão do aplicativo que está sendo executado no momento. AppExeName contém o nome do arquivo exe a ser carregado nessa pasta. Quando uma atualização de aplicativo for concluída, a etapa final será modificar o valor de AppFolderName para apontar para a nova versão do aplicativo. Dessa forma, na próxima vez que o usuário executar o aplicativo, a nova versão atualizada do aplicativo será executada. AppLaunchMode especifica como o aplicativo é carregado. Existem duas maneiras de carregar aplicativos: A primeira maneira é usar AppDomains. AppDomains é um recurso do Common Language Runtime do .NET Framework e também é uma unidade lógica independente e um objeto de gerenciamento. O Common Language Runtime permite vários domínios de aplicativo por processo. Dessa forma, o Appstart.exe pode carregar seu aplicativo em um AppDomain separado, mas no mesmo processo AppStart.exe. Apesar de existirem dois programas exe diferentes em execução (ou seja, Appstart.exe e MyApp.exe), apenas um processo está sendo usado. AppDomains funcionará perfeitamente para a maioria dos aplicativos, embora existam algumas diferenças sutis entre executar em um AppDomain separado e executar em um processo separado. Nesse caso, AppLaunchMode pode ser definido como "processo", o que fará com que o aplicativo seja carregado em um processo separado.
Depois que o Appstart inicia o aplicativo, ele entra em suspensão aguardando o encerramento do aplicativo. Assim que o aplicativo for encerrado, o Appstart também será fechado.
3. Passo a passo de exemplo
Anteriormente, discutimos como funciona a atualização de aplicativos .NET, agora vamos aplicá-la a um exemplo.
Etapa 1: Criar um aplicativo para atualização
1. Use o VS.NET para gerar um novo projeto de aplicativo do Windows, denominado "SampleApp".
2. Dê ao formulário uma cor de fundo interessante de sua escolha. Usaremos uma cor de fundo para diferenciá-lo das versões atualizadas posteriormente.
3. Agora vamos adicionar um recurso sutil a este aplicativo. Primeiro, adicione um botão ao seu formulário. O arquivo compactado contém um assembly com um Windows Form simples. Adicione uma referência ao assembly SamplesSampleAppSimpleForm no arquivo compactado. Em seguida, adicione duas linhas de código ao manipulador de eventos do botão:
..
SimpleForm.Form1 F = new SimpleForm.Form1();
F.Mostrar();
4. Converta seu sinalizador de construção de depuração para RELEASE. Isso nos permitirá evitar problemas de bloqueio de arquivo pdb posteriormente, quando construirmos uma nova versão do aplicativo enquanto a cópia original estiver em execução. Crie e teste seu aplicativo.
Etapa 2: Adicionar o componente de atualização do aplicativo .NET
1. Na guia Componentes da barra de ferramentas do VS.NET, clique com o botão direito e selecione "Personalizar barra de ferramentas". Selecione a guia "Componentes do .NET Framework". Clique em "Procurar" e selecione AppUpdater.dll localizado no projeto AppUpdater no arquivo compactado, clique em OK.
2. Um ícone do AppUpdater agora deve aparecer na parte inferior da lista de componentes da barra de ferramentas. Arraste e solte o componente AppUpdater no formulário SampleApp. Uma instância do componente .NET Application Update chamada appUpdater1 aparece na parte inferior do formulário.
Etapa 3: Configurar o componente de atualização do aplicativo .NET
Nesta etapa configuraremos o componente de atualização do aplicativo .NET. Observe que neste exemplo você só precisa alterar as primeiras quatro propriedades, deixando o restante com seus valores padrão.
Atributo AppUpdater: Este é o núcleo da atualização do aplicativo .NET As seguintes configurações precisam ser feitas para este programa:
(1) AutoFileLoad: Isso controla as características de download do comando a serem descritas posteriormente.
(2) ChangeDetectionMode: esta enumeração determina como verificar atualizações. Neste exemplo, usaremos uma verificação explícita do servidor, portanto defina esse valor como "ServerManifestCheck".
(3) ShowDefaultUI: O componente de atualização do aplicativo .NET possui uma série de interfaces de usuário para notificar os usuários sobre alguns eventos, como uma nova atualização disponível ou um erro ocorrido durante a atualização. Esta UI pode ser desabilitada definindo a UI padrão como inválida e substituindo-a por uma UI personalizada específica do aplicativo, conectando-se aos eventos apropriados (por exemplo,
OnUpdateComplete) e abra a interface de usuário personalizada. Neste exemplo usaremos a interface de usuário padrão, portanto defina esse valor como verdadeiro.
(4) UpdateUrl: UpdateUrl determina onde o programa de atualização procurará por atualizações. Neste exemplo, estamos usando um arquivo explícito do servidor para verificar atualizações, portanto, esta propriedade deve ser definida como a URL do arquivo explícito do servidor.
Neste exemplo, configure-o como: http://yourWebserver/SampleApp_ServerSetup/UpdateVersion.xml . Substitua "yourWebserver" pelo nome do seu servidor Web.
Propriedade Downloader: O componente AppUpdater possui dois subcomponentes. O primeiro é chamado Downloader, que controla as propriedades de download e Poller do componente: O segundo subcomponente do AppUpdater é Poller, que controla a verificação de atualizações.
(1)AutoStart: valor booleano que controla se o Poller deve iniciar a sondagem quando a aplicação é iniciada ou se deve esperar até que uma consulta de atualização planejada seja iniciada.
(2) DownloadOnDetection: valor booleano, controla se o Poller inicia o download das atualizações imediatamente quando uma nova atualização é descoberta ou se deve iniciar o download explícito chamando o método DownloadUdpate().
(3)InitialPollInterval: O número de segundos de espera antes de realizar a primeira verificação de atualização após o início do aplicativo.
(4)PollInterval: Após a primeira verificação de atualização, PollInterval controla o número de segundos entre cada verificação de atualização subsequente. Nota: O padrão é verificar a cada 30 segundos, obviamente, você desejará que seu aplicativo reduza o número de verificações de atualização. .
Depois de tudo isso feito, sua tabela de propriedades deverá ficar assim:
O diretório SamplesSampleAppSampleApp_Complete contém uma versão instalada corretamente do aplicativo.
Instalação:
(1)DownloadRetryAttempts: Se ocorrer um erro durante o download (como o servidor Web inativo), o downloader tentará novamente mais tarde. Esta propriedade controla o número de vezes que o downloader tenta novamente uma solicitação de rede antes de considerá-la um erro completo de atualização do aplicativo.
(2)SecondsBeteweenDownloadRety: O número de segundos de espera antes de tentar novamente a solicitação de rede.
(3)UpdateRetryAttempts: Se ocorrer um erro grave durante a atualização (por exemplo, o downloader excede o número de tentativas), um erro de atualização do aplicativo será gerado. Por padrão, as tentativas de atualização serão interrompidas. Mas ele tentará se recuperar na próxima vez que o aplicativo for iniciado (por exemplo, a atualização do servidor web pode ficar inativa por vários dias). Esta propriedade controla o número de tentativas de atualização. Se este valor for excedido, o atualizador cancela a atualização, redefine seu estado e retorna à verificação de atualização.
(4)ValidateAssemblies: Este atributo controla o nível em que os assemblies baixados são efetivamente concluídos. Consulte a seção Segurança deste artigo para obter mais informações.
Etapa 4: Gere e implemente a versão V1 do aplicativo no cliente.
No projeto SampleApp, abra o arquivo AssemblyInfo.cs. Modifique o valor de AssemblyVersion de "1.0" para "1.0.0.0". Isso faz com que ao construir o assembly obtenha uma tag com o valor "1.0.0.0".. em vez do valor que o VS.NET normalmente especifica como um incremento.
1. Crie o aplicativo.
2. Copie o diretório SamplesSampleAppSampleApp_ClientSetup do arquivo compactado para sua máquina local. Observe que este diretório já contém AppStart.exe. AppStart.config foi configurado para apontar para o diretório 1.0.0.0 e iniciar SampleApp.exe.
Copie SampleApp (Appupdater.dll, SimpleForm.dll e SampleApp.exe) do diretório de lançamento de SampleApp
para o diretório do cliente SampleApp_ClientSetup1.0.0.0. Neste ponto, uma versão totalmente funcional do aplicativo foi “instalada” no cliente e pode ser executada executando AppStart.exe.
Etapa 5: Instalar o servidor Web
Nesta etapa instalaremos o servidor Web para fornecer a funcionalidade de pesquisa de atualização. O componente .NET Application Update usa HTTP-DAV para baixar atualizações de aplicativos e, portanto, requer um servidor Web que ofereça suporte a HTTP-DAV. IIS5.0 no Windows 2000 e sistemas operacionais mais recentes oferecem suporte a HTTP-DAV.
1. Copie o diretório Samples/SampleApp_ServerSetup para o diretório wwwroot em seu servidor Web.
2. Copie a versão V1 do SampleApp para a pasta 1.0.0.0 do servidor web.
3. Habilite a permissão "Navegar no diretório" do IIS para o diretório SampleApp_ServerSetup no servidor web.
Passo Seis: Atualizar Aplicativos Automaticamente
OK,... Agora é hora de ver os resultados de todo esse trabalho duro instalando automaticamente uma nova versão.
1. Se a versão do SampleApp implementada no cliente não estiver em execução, carregue-a e deixe-a executar.
2. Volte para o VS.NET e faça algumas alterações visíveis no formulário SampleApp (como alterar a cor de fundo).
3. Altere as informações de versão de AssemblyInfo.cs para 2.0.0.0.
4. Regenerar.
5. Retorne ao servidor Web e gere um diretório 2.0.0.0 que seja equivalente ao diretório 1.0.0.0. Copie a nova versão do aplicativo do diretório de geração de release para o diretório 2.0.0.0 recém-criado no servidor Web.
6. Abra UpdateVersion.xml e modifique AvailableVersion para 2.0.0.0. Modifique ApplicationURL para apontar para o novo caminho 2.0.0.0.
7. Salve as alterações feitas em UpdateVersion.xml.
Depois de salvar o novo UpdateVersion.xml, em 30 segundos, a execução de cópias do SampleApp detectará a nova versão disponível.
4. Instalação sob demanda, segurança, escalabilidade e depuração
(1) Instalação sob demanda
A chamada instalação sob demanda significa que apenas o programa executável principal é explicitamente instalado no computador cliente. O restante do aplicativo pode ser baixado e instalado automaticamente com base nas necessidades básicas.
Inicie a instalação sob demanda por meio da propriedade AutoFileLoad do componente de atualização do aplicativo .NET. Você deve considerar cuidadosamente onde estão os limites do assembly em seu aplicativo e quais ações farão com que o download do assembly seja feito. Como o download da montagem envolve entrada e saída da rede, o tempo necessário para fazer o download é variável. Durante o download do assembly, o aplicativo fica congelado aguardando a conclusão do download do assembly.
(2) Implantação
A capacidade de instalar automaticamente atualizações de aplicativos com segurança traz muitos benefícios, mas também traz alguns perigos potenciais. Ao facilitar a instalação de atualizações, você também pode facilitar a instalação de códigos maliciosos se não tomar cuidado. Existem dois perigos. O primeiro perigo é que alguém use seu próprio servidor web para enganar o servidor web usado para implantar atualizações. Eles podem usar esse servidor web para instalar um vírus no caminho do seu aplicativo. A maneira mais simples de evitar falsificação ou outras interferências inadequadas na rede é usar HTTPS. Para usar HTTPS com o componente .NET Application Update, basta substituir URLs HTTP por URLs HTTPS. Claro, HTTPS não é uma solução mágica. Existem dois problemas com o uso de HTTPS. O primeiro é a escalabilidade. O uso de HTTPS exige que o servidor criptografe todos os arquivos baixados do servidor web. Se os arquivos de atualização de um aplicativo forem grandes, o custo de criptografia dos arquivos de atualização poderá sobrecarregar o servidor. Outro problema com o uso de HTTPS é que ele não beneficia em nada o segundo perigo à segurança. O segundo perigo é que os hackers possam atacar seu servidor tanto por dentro quanto por fora. Se o ataque for bem-sucedido, poderá significar que centenas ou milhares de clientes também serão afetados pelas atualizações automáticas, o que seria catastrófico.
Para resolver esse problema, o componente Atualização de Aplicativo .NET usa o recurso de nome forte para assemblies .NET para verificar assemblies baixados. Se o componente .NET Application Update detectar que um assembly não está assinado com sua chave durante o download, o download será cancelado. Isto significa que apenas alguém com a chave privada da sua aplicação pode criar atualizações que podem ser implementadas automaticamente.
Para verificar se o assembly é válido, o componente .NET Application Update verifica se a chave pública do executável do aplicativo atualmente instalado e a chave pública da atualização baixada correspondem. Se dois assemblies forem assinados com a mesma chave privada secreta, a chave pública incorporada será a mesma. Como o assembly que está sendo carregado pelo CLR verifica sua chave pública, o CLR calcula sua verificação de hash normal para garantir que o assembly é de fato um assembly genuíno e não um assembly adulterado. Para habilitar a validação no momento do download, adicione nomes fortes a todos os assemblies do seu aplicativo e defina a propriedade ValidateAssemblies do componente .NET Application Update como true.
A verificação da montagem na hora do download ajuda muito, mas na prática, muitas vezes as aplicações terão componentes assinados com chaves privadas diferentes. Por exemplo, seu aplicativo pode ter dois arquivos: um assembly executável assinado com sua chave privada e outro assembly dll que contém um controle de gráfico de terceiros que você comprou e usou em seu aplicativo. Assemblies de terceiros podem ser assinados usando a chave privada de terceiros em vez da sua própria. Para complicar ainda mais a situação, a configuração de chaves privadas válidas usadas para assinar assemblies em seu aplicativo pode mudar de número de versão para número de versão. Como você atualiza automaticamente esses tipos de aplicativos? Para resolver esse problema, você pode gerar um assembly em seu aplicativo que contenha uma lista de chaves públicas válidas. Assine o assembly com a chave privada mestra do aplicativo (a chave usada para assinar o arquivo exe do aplicativo) e coloque o assembly em um diretório no servidor web com os arquivos de atualização do aplicativo. Antes de o processo de download da atualização começar, o componente Atualização do aplicativo .NET verificará um assembly chamado "AppUpdaterKeys.dll" no diretório de atualização do aplicativo no servidor Web. Se presente, o assembly será baixado. O assembly é verificado em relação à chave pública do aplicativo principal. Se a assinatura for válida, a lista de chaves será extraída. A partir de agora, qualquer chave nesta lista será considerada uma assinatura válida para o arquivo atualizado.
A abordagem de segurança recomendada é usar URLs HTTPS para verificações de atualização. Isso fornece o primeiro nível de proteção contra falsificação. Para downloads de atualizações, é melhor não usar RLs HTTPS para evitar sobrecarregar seu servidor web. Em vez disso, adicione nomes fortes aos assemblies do seu aplicativo e use o recurso de validação de assembly.
(3) Escalabilidade
No exemplo mencionado anteriormente neste artigo, simplesmente arrastamos e soltamos um componente no aplicativo e definimos algumas propriedades para obter implantação automática.
Embora isso funcione bem em muitos aplicativos, alguns exigem um alto nível de controle que só pode ser obtido escrevendo código. Podemos escrever nosso próprio código para substituir o processo padrão do componente de atualização do aplicativo .NET, usando os métodos CheckForUpdate() e ApplyUpdate() substituídos para personalizar o comportamento de verificação e atualização.
(4) Depuração
Esta seção irá apontar algumas opções preferenciais de depuração, bem como descrever os problemas mais comuns enfrentados pelos usuários deste componente.
O .NET Application Updater gera um arquivo de log oculto chamado AppUpdate.log no mesmo diretório que AppStart.exe.
Todas as informações de sucesso e falha de atualização são registradas neste log. O arquivo de log é particularmente útil quando um cliente específico não consegue atualizar com êxito.
Você pode usar os logs para determinar quando e como as atualizações falharam. Além disso, o componente .NET Application Update usa a classe Debug do .NET Framework para gerar uma grande variedade de informações úteis. Se você executar seu aplicativo no depurador, verá essas informações na janela de saída. Você pode seguir os logs do atualizador de aplicativos .NET para destacar e encontrar as áreas problemáticas.
Se por algum motivo você não conseguir fazer o atualizador de aplicativos .NET funcionar, certifique-se do seguinte antes de se aprofundar na depuração. O problema que você está encontrando é provavelmente um dos seguintes: ..
Você navegou para o IIS. diretório? Caso contrário, o atualizador não baixará e instalará nenhum arquivo.
. Você implantou tudo corretamente e configurou o URL corretamente?
. Se o seu aplicativo estiver instalado no diretório de arquivos de programas, você tem certeza de que é o superadministrador ou superusuário da máquina? Caso contrário, você não terá acesso de gravação para atualizar o aplicativo.
. Você está gerando o objeto AppUpdater no thread de UI principal do aplicativo? Caso contrário, o atualizador não será capaz de exibir a UI e falhará ao disparar um evento de volta para a UI.
. A atualização foi bem-sucedida, mas o aplicativo não reinicia automaticamente com a nova atualização? O componente .NET Application Update tenta sair do aplicativo chamando o método Application.Exit. No entanto, este método não garante o fechamento de um aplicativo. Se você gerar e deixar um thread separado em execução, esse método não poderá encerrar o processo. A solução para garantir que todos os threads sejam encerrados é chamar o evento Application.OnExit ou conectar-se ao evento OnUpdateComplete do atualizador de aplicativo .NET e lidar com o desligamento você mesmo.
5. Resumo
A implantação conveniente de aplicativos clientes é uma meta importante da primeira versão do .NET Framework. Usar a estrutura .NET é uma ótima técnica para construir aplicativos clientes que resolvem problemas de implantação. A facilidade de implantação continua sendo uma meta importante para futuras novas versões do .NET Framework. Como solução, o componente de atualização de aplicativos .NET descrito aqui representa algumas de nossas ideias que poderemos usar diretamente em versões futuras do .NET Framework. No entanto, antes que esse momento chegue, o componente de atualização de aplicativos .NET pode ser considerado uma forma importante de começar a construir aplicativos de atualização automática.
De: csdn, vi em Tianji, ainda não estudei com atenção. vou deixar para mais tarde.