CA2134: Métodos devem manter a transparência consistente quando os métodos base

TypeName	MethodsMustOverrideWithConsistentTransparency
CheckId	CA2134
<strong>Categoria</strong>	Microsoft.Security
Alteração significativa	Quebrando

Causa

Essa regra é acionado quando um método marcado com o SecurityCriticalAttribute substitui um método que é transparente ou marcados com o SecuritySafeCriticalAttribute.A regra também é acionado quando um método que é transparente ou marcados com o SecuritySafeCriticalAttribute substitui um método marcado com um SecurityCriticalAttribute.

A regra é aplicada ao substituir um método ou a implementação de uma interface.

Descrição da regra

Essa regra é acionado na tentativa de alterar a acessibilidade de segurança de um método a cadeia de herança.Por exemplo, se um método virtual na classe base é transparente ou crítica safe, em seguida, a classe derivada deve substituí-lo com um método transparente ou safe crítico.Por outro lado, se o virtual é crítica de segurança, a classe derivada deve substituí-lo com um método de segurança críticos.A mesma regra se aplica para implementar os métodos de interface.

Regras de transparência são aplicadas quando o código é compilado em vez de em tempo de execução, de JIT para que o cálculo de transparência não tem informações de tipo dinâmico.Portanto, o resultado do cálculo de transparência deve ser capaz de ser determinada unicamente com os tipos estáticos compilação JIT, independentemente do tipo dinâmico.

Como corrigir violações

Para corrigir uma violação desta regra, altere a transparência do método que está substituindo um método virtual ou implementação de uma interface para coincidir com a transparência de virtual ou o método de interface.

Quando suprimir avisos

Não suprimir avisos da regra.Violações desta regra resultará em um tempo de execução TypeLoadException para assemblies que usam a transparência de nível 2.

Exemplos

Código

using System;
using System.Security;

namespace TransparencyWarningsDemo
{

    public interface IInterface
    {
        void TransparentInterfaceMethod();

        [SecurityCritical]
        void CriticalInterfaceMethod();
    }

    public class Base
    {
        public virtual void TransparentVirtual() { }

        [SecurityCritical]
        public virtual void CriticalVirtual() { }
    }

    public class Derived : Base, IInterface
    {
        // CA2134 violation - implementing a transparent method with a critical one.  This can be fixed by any of:
        //   1. Making IInterface.TransparentInterfaceMethod security critical
        //   2. Making Derived.TransparentInterfaceMethod transparent
        //   3. Making Derived.TransparentInterfaceMethod safe critical
        [SecurityCritical]
        public void TransparentInterfaceMethod() { }

        // CA2134 violation - implementing a critical method with a transparent one.  This can be fixed by any of:
        //   1. Making IInterface.CriticalInterfaceMethod transparent
        //   2. Making IInterface.CriticalInterfaceMethod safe critical
        //   3. Making Derived.TransparentInterfaceMethod critical
        public void CriticalInterfaceMethod() { }

        // CA2134 violation - overriding a transparent method with a critical one.  This can be fixed by any of:
        //   1. Making Base.TrasnparentVirtual critical
        //   2. Making Derived.TransparentVirtual transparent
        //   3. Making Derived.TransparentVirtual safe critical
        [SecurityCritical]
        public override void TransparentVirtual() { }

        // CA2134 violation - overriding a critical method with a transparent one.  This can be fixed by any of:
        //   1. Making Base.CriticalVirtual transparent
        //   2. Making Base.CriticalVirtual safe critical
        //   3. Making Derived.CriticalVirtual critical
        public override void CriticalVirtual() { }
    }

}

Consulte também

Conceitos

Código de segurança transparente, nível 2