Les types de conteneurs statiques doivent être sealed

Mise à jour : novembre 2007

Cause

Un type public ou protégé contient uniquement des membres statiques et n'est pas déclaré avec le modificateur sealed (Référence C#) (NotInheritable).

Description de la règle

Cette règle suppose qu'un type qui contient uniquement des membres statiques n'est pas conçu pour être hérité, car il ne fournit pas toutes les fonctionnalités qui peuvent être substituées dans un type dérivé. Un type qui n'est pas destiné à être hérité doit être marqué avec le modificateur sealed pour permettre son utilisation en tant que type de base.

Comment corriger les violations

Pour corriger une violation de cette règle, marquez le type en tant que sealed. Si vous ciblez .NET Framework 2.0 ou une version antérieure, une meilleure approche consiste à marquer le type comme static. Vous évitez ainsi de devoir déclarer un constructeur privé pour empêcher la création de la classe.

Quand supprimer les avertissements

Supprimez un avertissement de cette règle uniquement si le type est conçu pour être hérité. L'absence du modificateur sealed laisse entendre que le type est utile en tant que type de base.

Exemple de violation

Description

L'exemple suivant affiche un type qui enfreint la règle.

Code

Imports System

Namespace DesignLibrary

    Public Class StaticMembers

        Private Shared someField As Integer 

        Shared Property SomeProperty As Integer
            Get
                Return someField
            End Get
            Set
                someField = Value
            End Set
        End Property

        Private Sub New()
        End Sub

        Shared Sub SomeMethod()
        End Sub

    End Class

End Namespace

using System;

namespace DesignLibrary
{
    public class StaticMembers
    {
        static int someField;

        public static int SomeProperty
        {
            get
            {
                return someField;
            }
            set
            {
                someField = value;
            }
        }

        StaticMembers() {}

        public static void SomeMethod() {}
    }
}

using namespace System;

namespace DesignLibrary
{
    public ref class StaticMembers
    {
        static int someField;

        StaticMembers() {}

    public:
        static property int SomeProperty
        {
            int get()
            {
                return someField;
            }

            void set(int value)
            {
                someField = value;
            }
        }

        static void SomeMethod() {}
    };
}

Résoudre avec le modificateur statique

Description

L'exemple suivant indique comment résoudre une violation de cette règle en marquant le type avec le modificateur static.

Code

using System; 

namespace DesignLibrary
{    
    public static class StaticMembers    
    {        
        private static int someField;     

        public static int SomeProperty        
        {            
            get { return someField; }            
            set { someField = value; }        
        }                

        public static void SomeMethod()         
        {        
        }         

        public static event SomeDelegate SomeEvent;    
    }     

    public delegate void SomeDelegate();
}

Règles connexes

Les types de conteneurs statiques ne doivent pas comporter de constructeur