CA2134 : La transparence des méthodes doit rester cohérente lors de la substitution de méthodes de base

Cause

Cette règle se déclenche lorsqu'une méthode marquée avec l' SecurityCriticalAttribute substitue une méthode qui est transparente ou marquée avec l' SecuritySafeCriticalAttribute.La règle se déclenche également lorsqu'une méthode transparente ou marquée avec SecuritySafeCriticalAttribute se substitue à une méthode marquée avec SecurityCriticalAttribute.

La règle est appliquée lors de la substitution d'une méthode virtuelle ou de l'implémentation d'une interface.

Description de la règle

Cette règle déclenche sur les tentatives de modification de l'accessibilité à la sécurité d'une méthode située plus haut dans la chaîne d'héritage.Par exemple, si une méthode virtuelle dans une classe de base est transparente ou critique sécurisée, alors, la classe dérivée doit la substituer par une méthode transparente ou sécurisée critique.Inversement, si le virtuel est critique de sécurité, la classe dérivée doit le substituer avec une méthode critique de sécurité.La même règle s'applique pour l'implémentation des méthodes d'interface.

Les règles de transparence sont mises en vigueur lorsque le code est compilé par le JIT et non au moment de l'exécution, afin que le calcul de transparence n'ait pas d'informations de type dynamique.Par conséquent, le résultat du calcul de transparence doit pouvoir être déterminé uniquement à partir des types statiques qui sont compilés par le JIT, indépendamment du type dynamique.

Comment corriger les violations

Pour résoudre une violation de cette règle, modifiez la transparence de la méthode qui remplace une méthode virtuelle ou implémente une interface pour restituer la transparence de la méthode virtuelle ou d'interface.

Quand supprimer les avertissements

Ne supprimez aucun avertissement de cette règle.Les violations de cette règle provoquent une TypeLoadException runtime pour les assemblys qui utilisent la transparence de niveau 2.

Exemples

Code

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

}

Voir aussi

Concepts

Code transparent de sécurité, niveau 2