Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Regiões de execução restrita

Uma região de execução limitada (CER) é parte de um mecanismo para criação de código gerenciado confiável. Um CER define uma área em que o runtime de linguagem comum (CLR) é restrito, não podendo lançar exceções fora de banda que impediriam a execução do código na área em sua totalidade. Dentro dessa região, o código do usuário é limitado, não executando código que resultaria em lançar exceções fora de banda. O método PrepareConstrainedRegions deve preceder imediatamente um bloco try e marca os blocos catch, finally e fault como regiões de execução limitada. Uma vez marcado como uma região restrita, o código deve somente chamar outro código com contratos fortemente confiáveis, e não deve alocar ou fazer chamadas virtuais para métodos não preparados ou não confiáveis, a menos que o código esteja preparado para lidar com falhas. O thread de atrasos CLR aborta para código executando em um CER.

Regiões de execução limitada são usadas em formulários diferentes no CLR, além de um bloco anotado try, finalizadores notavelmente críticos executando em classes derivadas da classe CriticalFinalizerObject e código executado usando o método ExecuteCodeWithGuaranteedCleanup.

O CLR prepara CERs antecipadamente para evitar condições de memória insuficiente. Preparação antecipada é necessária para que o CLR não cause uma condição de falta de memória durante a compilação just-in-time ou o carregamento do tipo.

O desenvolvedor é necessário para indicar que uma região do código é um CER:

Usuários são limitados quanto ao tipo de código que podem escrever em um CER. O código não pode causar uma exceção fora de banda, como pode resultar das seguintes operações:

  • Alocação explícita.

  • Boxing.

  • Adquirir um bloqueio.

  • Chamando virtualmente métodos não preparados.

  • Chamando métodos com um contrato com pouca ou nenhuma confiabilidade.

No .NET Framework versão 2.0, essas restrições são diretrizes. Diagnósticos são fornecidos por ferramentas de análise de código.

O ReliabilityContractAttribute é um atributo personalizado que documenta as garantias de confiabilidade e o estado de corrupção de um método especificado.

ms228973.collapse_all(pt-br,VS.110).gifGarantias de Confiabilidade

As garantias de confiabilidade, representadas por valores de enumeração Cer, indicam o grau de confiabilidade de um determinado método:

  • MayFail . Em circunstâncias excepcionais, o método pode falhar. Nesse caso, o método relata de volta para o método que o chamou, se foi bem-sucedido ou falhou. O método precisa estar contido em uma CER para garantir que pode relatar o valor de retorno.

  • None . O método, tipo, ou assembly não tem concepção de um CER e provavelmente não é seguro chamar em um CER sem uma mitigação substancial do estado de corrupção. Não tira vantagem das garantias da CER. Isso implica o seguinte:

    1. Em circunstâncias excepcionais, o método pode falhar.

    2. O método pode relatar ou não que falhou.

    3. O método não é escrito para usar um CER, o cenário mais provável.

    4. Se um método, tipo, ou assembly não é identificado explicitamente para obter êxito, é identificado implicitamente como None.

  • Success . Em circunstâncias excepcionais, o método é garantido de ter êxito. Para conquistar esse nível de confiabilidade você deve sempre criar um CER em torno do método que é chamado, mesmo quando é chamado de uma região não CER. Um método é bem-sucedido quando realiza o que é esperado, embora êxito possa ser visto subjetivamente. Por exemplo, marcando Contagem com ReliabilityContractAttribute(Cer.Success) significa que quando é executado em uma CER, ele sempre retorna uma contagem do número de elementos na ArrayList e nunca pode sair dos campos internos em um estado indefinido. No entanto, o método CompareExchange é marcado como sucesso também, com o entendimento que êxito pode significar que o valor não pode ser substituído por um novo valor devido a uma condição de corrida. O ponto-chave é que o método se comporta da forma que está documentado para se comportar, e o código CER não precisa ser escrito para esperar qualquer comportamento incomum além do que código correto mas não confiável pareceria.

ms228973.collapse_all(pt-br,VS.110).gifNíveis de corrupção

Os níveis de danos, representados pelos valores de enumeração Consistency, indicam quanto um estado pode estar corrompido em um ambiente determinado:

  • MayCorruptAppDomain . Em circunstâncias excepcionais, o runtime de linguagem comum (CLR) não faz garantias em relação à consistência do estado no domínio do aplicativo atual.

  • MayCorruptInstance . Em circunstâncias excepcionais, o método limitará a corrupção de estado para a instância atual.

  • MayCorruptProcess , sob circunstâncias excepcionais, o CLR não faz garantias em relação à consistência do estado; ou seja, a condição pode corromper o processo.

  • WillNotCorruptState . Em circunstâncias excepcionais, o método não danificará o estado.

A confiabilidade try/catch/finally (Tentativa/Captura/Final) é um mecanismo de manipulação de exceção com o mesmo nível de garantias previsíveis que a versão não gerenciada. O bloco catch/finally (Captura/Final) é o CER. Métodos no bloco requerem a preparação antecipada e devem ser não ininterrupta.

No .NET Framework versão 2.0, o código informa ao runtime que uma tentativa é confiável chamando PrepareConstrainedRegions imediatamente antes de um bloco tentativa. PrepareConstrainedRegions é um membro de RuntimeHelpers, uma classe de suporte do compilador. Chame PrepareConstrainedRegions diretamente pendente sua disponibilidade nos compiladores.

Uma região ininterrupta agrupa um conjunto de instruções em um CER.

No .NET Framework versão 2.0, pendente a disponibilidade no suporte do compilador, o código do usuário cria regiões ininterruptas com uma tentativa/captura/final confiável que contém um bloco tentativa/captura vazio precedido por uma chamada de método PrepareConstrainedRegions.

CriticalFinalizerObject garante que a coleta de lixo executará o finalizador. Quanto a alocação, o finalizador e seu gráfico de chamada são preparados antecipadamente. O método finalizador é executado em um CER, e deve obedecer todas as restrições em CERs e em finalizadores.

Quaisquer heranças de tipo do SafeHandle e CriticalHandle são garantidas de ter a execução de seu finalizador em um CER. Implemente ReleaseHandle em classes derivadas SafeHandle para executar qualquer código necessário para liberar o identificador.

As seguintes operações não são permitidas em CERs:

  • Alocações explícitas.

  • Adquirir um bloqueio.

  • Boxing.

  • Acesso de matriz multidimensional.

  • Chamadas de método através de reflexão.

  • Enter ou Lock.

  • Verificações de segurança. Não execute demandas, somente as de link.

  • Isinst e Castclass para objetos COM e proxies

  • Obter ou definir campos em um proxy transparente.

  • Série

  • Ponteiros de função e representantes.

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2014 Microsoft