Tentativa de ler ou escrever na memória protegida. Isso geralmente indica que outra memória está corrompida

Espero que alguém possa me esclarecer sobre o que poderia estar causando esse erro:

Tentativa de ler ou escrever na memória protegida. Isso geralmente indica que outras memórias estão corrompidas.

Não consigo realmente postar código porque esse erro parece ser lançado em qualquer área aleatória do aplicativo. O aplicativo será executado de 12 a 48 horas antes de gerar o erro. Às vezes, ele pára em um local aparentemente aleatório e gera o erro acima; outras vezes, o aplicativo inteiro para e uma tela com um erro informa algo como "Ocorreu um erro fatal em ... Isso pode ser um bug no CLR ou ... "algo sobre o PInvoke ou outras informações não relevantes. Quando isso acontece, todos os threads são mostrados terminados e não há informações de depuração disponíveis.

Em poucas palavras, é isso que o aplicativo faz:

É um aplicativo de servidor multiencadeado, escrito inteiramente em C #. Os clientes se conectam ao servidor via soquete. O servidor executa um "ambiente" virtual para os clientes, onde eles podem interagir entre si e com o ambiente. Consome bastante memória, mas não vejo vazamento. Consome tipicamente cerca de 1,5 GB. Não acho que esteja vazando porque o uso da memória permanece relativamente constante o tempo todo em que o aplicativo está sendo executado. Seu código constantemente em execução para manter o ambiente, mesmo que os clientes não estejam fazendo nada. Ele não usa software de terceiros ou outras APIs. Os únicos recursos externos que este aplicativo usa são conexões de soquete e conexões de banco de dados SQL. Está rodando em um servidor de 64 bits. Tentei depurar isso no VS2008 e VS2010 usando .net 2.0, 3.5 e 4.

Tentei desativar as otimizações do compilador e várias correções da Microsoft. Parece que nada resolve esse problema. Seria apreciado se alguém conhece alguma causa possível, ou algum tipo de maneira de identificar o que está causando o problema.

Acabei de enfrentar esse problema no VS 2013 .NET 4.5 com uma DLL MapInfo. Acontece que o problema foi que mudei a Plataforma para Build de x86 para Qualquer CPU e isso foi suficiente para disparar esse erro. Mudar de volta para x86 fez o truque. Pode ajudar alguém.

Também enfrentei esse problema com o Visual Studio (VS) 2010. Mais interessante, eu tinha vários projetos em minha solução (aplicativo de console, aplicativo WPF, aplicativo Windows Forms), mas ele falhou apenas quando, eu estava definindo o tipo "Aplicativo de console" do projeto como projeto inicial da solução (mesmo para aqueles que literalmente não tinham código ou nenhum conjunto adicional referido além dos padrões que vêm com o próprio modelo de projeto).

A seguinte mudança finalmente me ajudou a resolver o problema: Vá para as propriedades do projeto do aplicativo de console (como alternativa, selecione o arquivo do projeto no Solution Explorer e pressione Alt+ Entercombinação de teclas) -> Vá para a Debugguia -> Role para a Enable Debuggersseção no painel direito -> Marque a Enable unmanaged code debuggingcaixa de seleção, como mostrado no instantâneo abaixo -> Clique Floppyno botão na barra de ferramentas para salvar as propriedades do projeto. A causa raiz do porquê aconteceu ainda não é conhecida por mim. A única coisa que observei foi que havia muitas atualizações do Windows instaladas na minha máquina na noite anterior, que consistiam principalmente de atualizações do escritório e atualizações do sistema operacional (mais de uma dúzia de artigos da Base de Dados de Conhecimento).

Atualização : no VS 2017 em diante, o nome da configuração foi alterado conforme mostrado na captura de tela abaixo:

Finalmente rastreou isso com a ajuda do WinDBG e SOS. A violação de acesso estava sendo lançada por alguma DLL desconhecida. Acontece que um software chamado "Nvidia Network Manager" estava causando os problemas. Eu já havia lido inúmeras vezes como esse problema pode ser causado por firewalls ou antivírus, nenhum dos quais estou usando, por isso descartei essa ideia. Além disso, eu assumi que não era ambiental porque ocorre em mais de um servidor usando hardware diferente. Acontece que todas as máquinas em que testei estavam executando o "NVidia Network Manager". Acredito que ele seja instalado com o restante dos drivers da placa-mãe.

Espero que isso ajude alguém, pois esse problema atormentou meu aplicativo por um tempo muito longo.

O problema pode estar relacionado a DLLs de plataformas de compilação mistas no projeto. Você constrói seu projeto em Qualquer CPU, mas possui algumas DLLs no projeto já criadas para a plataforma x86. Isso causará falhas aleatórias devido ao mapeamento de memória diferente da arquitetura de 32 bits e de 64 bits. Se todas as DLLs forem criadas para uma plataforma, o problema poderá ser resolvido.

Tente executar este comando

redefinição netsh winsock

Fonte: https://stackoverflow.com/a/20492181/1057791

Este erro não deve ocorrer no código gerenciado. Isso pode resolver o problema:

Vá para o Visual Studio Debugger para ignorar esta exceção:

Tools menu ->Options -> Debugging -> General -> Uncheck this option "Suppress JIT optimization on module load"

Espero que ajude.

Encontrei uma solução para esta exceção hoje. Isso estava ocorrendo quando eu estava tentando depurar um teste de unidade (NUnit) que chamava de método virtual em uma classe abstrata.

O problema parece estar na instalação do .NET 4.5.1.

Fiz o download do .NET 4.5.2 e instalei (meus projetos ainda fazem referência ao .NET 4.5.1) e o problema foi resolvido.

Fonte da solução:

https://connect.microsoft.com/VisualStudio/feedback/details/819552/visual-studio-debugger-throws-accessviolationexception

Pode ser hardware. Pode ser algo complicado ... mas gostaria de sugerir que, em algum lugar, seu código de encadeamento não esteja protegendo alguma coleção (como um dicionário) com um bloqueio apropriado.

Qual SO e service pack você está executando?

Eu tive esse problema recentemente quando mudei o servidor de desenvolvimento para um projeto. Eu estava recebendo esse erro na linha de código em que declarei uma nova variável OracleConnection.

Depois de tentar várias coisas, incluindo a instalação de hotfixes, tentei alterar as referências Oracle.DataAccess e System.Data.OracleClient no projeto e funcionou!

Quando um projeto é movido para uma nova máquina, sugiro que você renove todas as referências adicionadas nesse projeto.

Você tentou desativar o DEP (Data Execution Prevention) para seu aplicativo?

Eu enfrentei o mesmo problema. Meu código era uma dll do .NET (extensão AutoCAD) em execução no AutoCAD 2012. Também estou usando o Oracle.DataAccess e meu código estava lançando a mesma exceção durante ExecuteNonQuery (). Felizmente, resolvi esse problema alterando a versão .net do ODP que estava usando (ou seja, 2.x do Oracle.DataAccess)

Esse problema é quase sempre invariavelmente simples. O código está ruim. Raramente são as ferramentas, apenas a partir de uma análise estatística. Incontáveis ​​milhões de pessoas estão usando o Visual Studio todos os dias e talvez algumas estejam usando seu código - que parte do código está obtendo os melhores testes? Garanto que, se esse fosse um problema com o VS, provavelmente já o teríamos encontrado.

O que a declaração significa é que, quando você tenta acessar a memória que não é sua, geralmente é porque você está fazendo isso com um ponteiro corrompido, que veio de outro lugar. É por isso que está indicando a indicação.

Com a corrupção de memória, a captura do erro raramente está próxima da causa raiz do erro. E os efeitos são exatamente o que você descreve, aparentemente aleatórios. Você apenas terá que olhar para os culpados de sempre, coisas como:

• ponteiros não inicializados ou outros valores.
• escrevendo mais em um buffer que seu tamanho.
• recursos compartilhados por threads que não são protegidos por mutexes.

Trabalhar de trás para frente a partir de um problema como esse para encontrar a causa raiz é incrivelmente difícil, pois muito poderia ter acontecido entre a criação do problema e a detecção do problema.

Acho que é mais fácil dar uma olhada no que é corrompido (por exemplo, um ponteiro específico) e depois fazer uma análise estática manual do código para ver o que poderia ter corrompido, verificando os culpados comuns, como mostrado acima. No entanto, mesmo isso não vai pegar longas cadeias de problemas.

Eu não estou familiarizado o suficiente com o VS para saber, mas você também pode querer examinar a possibilidade de usar uma ferramenta de rastreamento de memória (como o valgrind para Linux) para ver se ele pode detectar problemas óbvios.

O código verificável não deve ser capaz de corromper a memória; portanto, há algo inseguro acontecendo. Você está usando algum código não seguro em qualquer lugar, como no processamento de buffer? Além disso, as coisas sobre o PInvoke podem não ser irrelevantes, pois o PInvoke envolve uma transição para código não gerenciado e empacotamento associado.

Minha melhor recomendação é anexar a uma instância com falha e usar o WinDBG e o SOS para aprofundar o que está acontecendo no momento da falha. Isso não é para os fracos de coração, mas nesse momento você pode precisar quebrar ferramentas mais poderosas para determinar o que exatamente está errado.

Ok, isso pode ser bastante inútil e simplesmente anedótico, mas ...

Essa exceção foi lançada consistentemente por algumas bibliotecas Twain32 que estávamos usando no meu projeto, mas só aconteceria na minha máquina.

Tentei muitas soluções sugeridas em toda a Internet, sem sucesso ... Até desconectar o meu celular (ele estava conectado através do USB).

E funcionou.

Acontece que as bibliotecas Twain32 estavam tentando listar meu telefone como um dispositivo compatível com Twain, e algo que ele fez nesse processo causou essa exceção.

Vai saber...

Eu recebi esse erro ao usar o pinvoke em um método que faz referência a um StringBuilder. Eu tinha usado o construtor padrão que aparentemente aloca apenas 16 bytes. O Windows tentou colocar mais de 16 bytes no buffer e causou uma saturação do buffer.

Ao invés de

StringBuilder windowText = new StringBuilder(); // Probable overflow of default capacity (16)

Use uma capacidade maior:

StringBuilder windowText = new StringBuilder(3000);

no meu caso, o arquivo estava aberto e, portanto, bloqueado.

Eu estava conseguindo ao tentar carregar um arquivo do Excel usando o LinqToExcel que também foi aberto no Excel.

isso é tudo que eu fiz

    var maps = from f in book.Worksheet<NavMapping>()
                select f;
    try {
        foreach (var m in maps)
            if (!string.IsNullOrEmpty(m.SSS_ID) && _mappings.ContainsKey(m.SSS_ID))
                _mappings.Add(m.SSS_ID, m.CDS_ID);
    } catch (AccessViolationException ex) {
        _logger.Error("mapping file error. most likely this file is locked or open. " + ex);
    }

Eu recebi o mesmo erro em um projeto em que estava trabalhando no VB.NET. Verificar a opção "Ativar estrutura do aplicativo" na página de propriedades resolveu isso para mim.

Eu tive esse problema também . eu estava executando soluções diferentes ao mesmo tempo usando o visual studio; ao fechar outras soluções e executar apenas a solução de destino, funcionava bem sem esse erro.

Obtive esse erro aleatoriamente no VS1017, ao tentar criar um projeto que estava sendo perfeitamente perfeito no dia anterior. A reinicialização do PC corrigiu o problema funcionado (eu também executei o seguinte comando anteriormente, não sei se é necessário: netsh winsock reset)

Minha resposta depende muito do seu cenário, mas tivemos um problema ao tentar atualizar um aplicativo .NET para um cliente com mais de 10 anos para que eles pudessem fazê-lo funcionar no Windows 8.1. A resposta de @ alhazen estava no campo correto para mim. O aplicativo contava com uma DLL de terceiros que o cliente não queria pagar para atualizar (Pegasus / Accusoft ImagXpress). Nós direcionamos novamente o aplicativo para o .NET 4.5, mas cada vez que a seguinte linha era executada, recebíamos a AccessViolationException was unhandledmensagem:

UnlockPICImagXpress.PS_Unlock (1908228217,373714400,1341834561,28447);

Para corrigi-lo, tivemos que adicionar o seguinte evento pós-compilação ao projeto:

call "$(DevEnvDir)..\tools\vsvars32.bat"
"C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\amd64\editbin.exe" /NXCOMPAT:NO "$(TargetPath)"

Isso especifica explicitamente o executável como incompatível com o Data Execution Prevention. Para mais detalhes veja aqui .

Em alguns casos, isso pode acontecer quando:

obj = new obj();
...
obj.Dispose();  // <-----------------    Incorrect disposal causes it
obj.abc...

No meu caso, tive que fazer referência a uma biblioteca C / C ++ usando P / Invoke, mas tive que garantir que a memória fosse alocada para a matriz de saída primeiro usando fixed:

[DllImport("my_c_func_lib.dll", CharSet = CharSet.Ansi)]
public static extern unsafe int my_c_func(double input1, double input2, double pinput3, double *outData);

    public unsafe double[] GetMyUnmanagedCodeValue(double input1, double input2, double input3)
    {
        double[] outData = new double[24];

        fixed (double* returnValue = outData)
        {
            my_c_func(input1, input2, pinput3, returnValue);
        }

        return outData;
    }

Para obter detalhes, consulte: https://www.c-sharpcorner.com/article/pointers-in-C-Sharp/

Isso aconteceu comigo quando eu estava depurando meu aplicativo C # WinForms no Visual Studio. Meu aplicativo faz chamadas para coisas do Win32 via DllImport, por exemplo

[DllImport("Secur32.dll", SetLastError = false)]
private static extern uint LsaEnumerateLogonSessions(out UInt64 LogonSessionCount, out IntPtr LogonSessionList);

A execução do Visual Studio "como administrador" resolveu o problema para mim.

Eu tive a mesma mensagem de erro:

System.AccessViolationException: tentou ler ou gravar memória protegida. Isso geralmente indica que outras memórias estão corrompidas.

No meu caso, o erro desapareceu após a limpeza e reconstrução da solução.

No meu caso, o utilitário FTDI FT Prog estava lançando o erro ao procurar dispositivos USB. Desconectar meus fones de ouvido Bluetooth do PC corrigiu o problema.

Recebi esta mensagem de erro na expressão lambda que estava usando o Linq para filtrar uma coleção de objetos. Quando inspecionei a coleção, notei que seus membros não estavam preenchidos - na Localsjanela, expandi-los apenas mostrava "...". Por fim, o problema estava no método de repositório que inicialmente preencheu a coleção - o Dapper estava tentando mapear automaticamente uma propriedade de um objeto aninhado. Corrigi a consulta Dapper para lidar com o multi-mapeamento e isso corrigiu o erro de memória.