Compartilhar via


Alterações de código suportadas (C#)

Edit and Continue lida com a maioria dos tipos de alterações de código dentro de corpos de método.A maioria das alterações fora corpos e algumas alterações dentro de corpos de método não podem ser aplicadas durante a depuração, entretanto.Para aplicar essas alterações sem suporte, você deve parar a depuração e reiniciar com uma nova versão do código.

As seguintes alterações não podem ser aplicadas ao código de C# durante uma sessão de depuração:

  • Alterações para a instrução atual ou qualquer instrução ativa.

    Active statements incluem quaisquer instruções em funções na pilha de chamadas que foram chamadas para obter a instrução atual.

    A instrução atual é marcada por um fundo amarelo na janela de origem.Outros active statements são marcados por um plano de fundo sombreado e são somente leitura.Essas cores padrão podem ser alterados na Opções caixa de diálogo.

  • Alterações globais símbolos, incluindo o seguinte:

    • Adicionando novos tipos.

    • Adicionando métodos a um tipo.

    • Alterando a assinatura de um tipo.

    • Adicionando campos, eventos ou propriedades para um tipo.

  • Editando um método anônimo ou qualquer método que contém um método anônimo.Esses métodos são marcados por um plano de fundo sombreado.

  • Adicionando um novo método anônimo.

  • Adicionando, removendo ou alterando atributos.

  • Adicionando, removendo ou alterando using diretivas.

  • Remover ou alterar as variáveis locais.É permitido adicionar variáveis locais.

  • Adicionando um foreach, using, ou lock em torno de instrução ativa.

  • Modificando um método que contém um yield return ou yield break instrução.

  • Alterando um construtor com um campo inicializado por um método anônimo.

Código não seguro

Alterações de código não seguro têm as mesmas limitações que alterações de código seguro, com uma restrição adicional:

  • Editar e continuar não suportam alterações para código não seguro sai dentro de um método que contém o operador stackalloc.Isso se aplica apenas aos métodos ativos.Quando você está depurando, qualquer função no momento na pilha de chamadas é uma função ativa.

Exceções

Edição e continuação oferece suporte a alterações catch, finally,e try blocos, com algumas exceções para blocos de métodos ativos, como métodos que estão atualmente na pilha de chamadas.

  • Em uma função ativa que é a função mais recente na pilha de chamadas, editar e continuar não dá suporte:

    • Adicionando um catch ou finallybloco de instrução ativa.

    • Adicionando manipuladores de exceção aninhados com mais de seis níveis de aninhamento.

  • Em uma função ativa não é a função mais recente na pilha de chamadas, editar e continuar não dá suporte:

    • Adicionando um catch, finally ou trybloco de instrução ativa.

    • Adicionando manipuladores de exceção aninhados com mais de seis níveis de aninhamento.

    • Alterar código dentro de um trybloco que contém a instrução ativa.

Cenários sem suporte

Editar e continuar não está disponível nos seguintes cenários de depuração:

  • Depurar o código do LINQ.Para mais informações, consulte Edit and Continue Not Supported for LINQ.

  • Depuração de modo misto (nativo/gerenciado).

  • SQL de depuração.

  • Depuração um Dr.Despejo do Watson.

  • Edição do código após uma exceção não tratada, quando o "Unwind the call stack on unhandled exceptions" não está selecionada.

  • Depurando um aplicativo de tempo de execução incorporado.

  • Depurando um aplicativo que tenha Attach to em vez de executar o aplicativo, escolhendo Iniciar do Debug menu.

  • Depurar o código otimizado.

  • Depurando código gerenciado quando o destino é um aplicativo de 64 bits.Se você deseja editar e continuar, você deve definir o destino como x86.(ProjetoPropriedades, Compilar guia, Advanced Compiler configuração.)

  • Depuração de uma versão antiga do seu código após uma nova versão falhar a compilação devido a erros de compilação de.

Consulte também

Tarefas

Como: usar o Editar e continuar (C#)

Referência

Editar e continuar (Visual C#)

Editar e continuar a erros e avisos (C#)