Compartilhar via

Como: Melhore o desempenho

  • Artigo

As seguintes práticas de programação podem economizar memória e melhorar o desempenho de aplicativos para dispositivos.

Para economizar memória com Windows Forms e elementos gráficos

Para economizar memória com dados e sequências de caracteres

  • Usar variáveis inteiras (Int32 ou Int64) na for loops em vez de variáveis de objeto.

  • Evite usar o ToString método de uma enumeração por causa do impacto no desempenho que ele gera pesquisando tabelas de metadados.

  • Evitar OutOfMemoryException erros. Essa exceção pode ser lançada pelo common linguagem tempo de execução quando não há memória suficiente para alocar para fins internos ou novas instâncias de objetos.Para evitar essa exceção, evite programar métodos grandes que consomem mais ou de 64 kilobytes de memória.

  • Remover System.SR.dll, que contém mensagens de erro para caixas de diálogo de exceções.Você pode implantar seu aplicativo sem este arquivo para economizar memória.The .NET Compact Framework dinamicamente carrega strings de erro contidas em sistema.SR.dll se o arquivo estiver presente.

    Se esse arquivo .dll não estiver presente no dispositivo, todas as exceções contém a mensagem "Não é possível carregar o assembly de recursos." Durante o desenvolvimento, entretanto, é útil adicionar uma referência ao sistema.SR.dll ao seu Visual Studio projeto para que você veja exceções com significado.

  • As seqüências de caracteres são imutáveis, então, um novo String objeto é criado sempre que você modificar a seqüência de caracteres. Considere o uso de um StringBuilder Quando você construir uma seqüência de caracteres que será modificada freqüentemente.

  • Use o ParseExact método para um DateTime Se você souber o formato exato usado para DateTime serialização. Caso contrário, a DateTime Analisador tentará seqüencialmente aplicar diversos formatos específicos de cultura.

  • Limitar o número de em aberto SqlCeCommand os objetos e destrua eles quando terminar.

Para economizar memória quando interoperar com código nativo

  • Na plataforma de operações de invocação, usar tipos blittable, que têm uma representação comum em ambos gerenciado e un gerenciado memória, sistema autônomo Int32 ou IntPtr. Tipos de valor blittable maiores que 32 bits mais rapidamente são passados por referência que por valor.Para obter mais informações sobre tipos blittable, consulte Tipos blittable (que permitem transferência de bits) do .NET Compact Framework.

  • Use o InAttribute e OutAttribute atributos para os argumentos na sua assinatura de função para reduzir empacotamentos desnecessários.

  • Use sistema autônomo métodos no Marshal classe para manualmente converter entre IntPtr e gerenciado sistema autônomo objetos, PtrToStructure, PtrToStringBSTR, GetObjectForNativeVariant, e GetObjectForIUnknown.

  • Use o Prelink e PrelinkAll métodos para fazer compilação JIT do stub que oferece suporte nativo para gerenciado chamadas.

  • Se você espera que seu objeto COM nativo retorne S_FALSE sistema autônomo um caso comum, ou outros valores que não sejam S_OK HRESULT, conjunto o PreserveSig campo para true e faça a assinatura gerenciada corresponder a assinatura nativa. Isso evita a sobrecarga de um try/catch bloco é necessário quando o tempo de execução traduz valores HRESULT para exceções em suas chamadas com..

  • Faça quanto trabalho você puder em uma invocação de plataforma em vez de fazer várias chamadas.

Para economizar memória nas coleções

  • Use índices se a coleção se baseia em uma matriz.

  • Sempre que possível, especifique o tamanho da sua coleção, pois o redimensionamento dinâmico pode aumentar o excesso de armazenamento significativamente.

  • Use coleções genéricas para evitar sobrecarga de boxing e unboxing para tipos de valor.Definir suas próprias coleções otimizadas resultam em melhor desempenho.

Para economizar memória em XML

  • Use XmlTextReader e XmlTextWriter em vez de XmlDocument, que usa mais memória.

  • Especificar configurações para XmlReaderSettings e XmlWriterSettings para melhorar o desempenho. The IgnoreWhitespace e IgnoreComments valores de propriedade, se aplicável, podem melhorar o desempenho significativamente.

  • Use as codificações UTF-8, UTF-16 e ASCII, que são mais rápidas que as codificações ANSI e Windows codepage.

  • Evite usar um esquema(schema) para interpretação(parsing), pois isso requer trabalho de validação adicional.

  • Mapeie colunas sistema autônomo atributos e use um digitado DataSet Quando estiver preenchendo um DataSet de uma fonte XML.

  • Evite o seguinte quando estiver preenchendo um DataSet:

    • Schema inference.

    • Tabelas aninhadas.

    • Vários DateTime colunas. Para obter um melhor desempenho, use o Ticks valor da propriedade em vez disso.

  • As seguintes diretrizes melhoram o desempenho ao usar desserialização XML:

    • Manter nomes de elementos e atributos tão curtos quanto possível porque cada caractere deve ser validado.

    • XML baseado em dados de atributos é mais rápido que XML baseado em dados de elementos.

    • Use o XmlNodeReader.Skip método quando aplicável.

    • Considere a serialização binária quando o desempenho se tornar crítico.

  • Usar um XmlSerializer instância por tipo para serialização XML para reduzir a quantidade de time gasto procurando por metadados.

  • Como a serialização de grandes quantidades de XML pode utilizar mais memória, considere em vez disso, criar um mecanismo personalizado de serialização binária usando um BinaryReader e BinaryWriter.

Para economizar memória ao usar um serviço da Web

  • Use um DiffGram quando ler e gravar um DataSet. Para obter mais informações, consulte DiffGrams.

  • Salvar um remoto DataSet e seu esquema para o dispositivo sistema autônomo XML.

  • Faça uma chamada a um método simples de serviço da Web durante a sua tela inicial, pois a primeira chamada é mais lenta que as chamadas subsequentes.

  • Tenha cuidado ao manipular erros de rede e dados.

  • Em alguns casos, fazer serialização manual o DataSet sistema autônomo uma string XML antes de fazer uma telefonar de serviço Web resultados em melhor desempenho.

Para economizar memória em programação avançada

  • Processe operações grandes de forma assíncrona.

  • Evite chamadas virtuais.The .NET Compact Framework chamadas virtual do tempo de execução são aproximadamente 30 % mais lento do que estático ou chamadas de instância. The .NET Compact Framework não usa TabelaV devido de recursos restritos, para que os métodos devem ser chamados por percorrer a hierarquia de interface e classe, que é uma operação cara. The .NET Compact Framework mantém um cache de chamadas virtual resolvidos, portanto, na maioria dos casos chamadas não precisam ser reinterpretados.

  • Usar campos em vez de propriedades quando possível.

  • Substituir o GetHashCode e Equals métodos ao definir um tipo de valor. Se eles não são substituídos, o tempo de execução usa versões generalizadas para esses métodos no baseValueType classe.

  • Use a reflexão com cuidado.Usar reflexão para fins de investigação com classes não instanciadas pode afetar o desempenho dos objetos instanciados em seu aplicativo.

  • Tenha certeza de que os seus recursos gerenciados tenham nomes de tipo completamente qualificados e estão corretos no seu arquivo RESX.Eles devem ter a versão correta e os campos PublicKeyToken.O esforço para localizar o substituto mais apropriado para um tipo incorretamente especificado afeta o desempenho.

  • Observe que em alguns casos ler aplicativo dados diretamente do arquivo podem ser suficiente e mais eficiente do que usar ResourceManager. A ResourceManager pode sondar vários locais no sistema de arquivos para localizar uma melhor correspondência do asssembly satélite antes que ele localize o recurso binário. Use as ferramentas apropriadas para o trabalho.

Consulte também

Conceitos

Dispositivo de memória Management in the .NET Compact estrutura

Tópicos "como" do .NET compact estrutura

Outros recursos

Desempenho e o diagnóstico no .NET Compact estrutura