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() { }
}
}