Partilhar via


CA2134: os métodos devem manter uma transparência consistente durante a substituição dos métodos base

TypeName

MethodsMustOverrideWithConsistentTransparency

CheckId

CA2134

Categoria

Microsoft.Security

Alteração Significativa

Quebra

Causa

Esta regra é disparada quando um método marcado com SecurityCriticalAttribute substitui um método que é transparente ou marcado com SecuritySafeCriticalAttribute.A regra também é acionado quando um método que é transparente ou marcado com SecuritySafeCriticalAttribute substitui um método que está marcado com SecurityCriticalAttribute.

A regra é aplicada ao substituir um método virtual ou ao implementar uma interface.

Descrição da Regra

Esta regra é acionado em tenta alterar a acessibilidade de segurança de um método mais acima da cadeia de herança.Por exemplo, se um método virtual em uma classe base é transparente ou seguro- crítico, a classe derivada deve ser substituído pelo método ou transparente seguro- crítico.Entretanto, se o virtual é crítico segurança, a classe derivada deve ser substituído pelo método crítico de segurança.A mesma regra se aplica implementando métodos da interface.

As regras de transparência são impostas quando o código é JIT compilado em vez de em tempo de execução, de modo que o cálculo de transparência não tenha as informações de tipo dinâmico.Em virtude disso, o resultado de cálculo de transparência deve poder ser determinado somente os tipos estáticos sendo compilados, independentemente do tipo dinâmico.

Como Corrigir Violações

Para corrigir uma violação desta regra, alterar a transparência do método que está substituindo um método virtual ou estiver implementando uma interface para corresponder à transparência do método virtual ou da interface.

Quando Suprimir Alertas

Não suprima avisos desta regra.As violações desta regra resultarão 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 transparente de segurança, nível 2