CA1052: Static holder types should be sealed

Note

This article applies to Visual Studio 2015. If you're looking for Visual Studio 2017 documentation, use the version selector at the top left. We recommend upgrading to Visual Studio 2017. Download it here.

TypeName StaticHolderTypesShouldBeSealed
CheckId CA1052
Category Microsoft.Design
Breaking Change Breaking

Cause

A public or protected type contains only static members and is not declared with the sealed (NotInheritable) modifier.

Rule Description

This rule assumes that a type that contains only static members is not designed to be inherited, because the type does not provide any functionality that can be overridden in a derived type. A type that is not meant to be inherited should be marked with the sealed modifier to prohibit its use as a base type.

How to Fix Violations

To fix a violation of this rule, mark the type as sealed. If you are targeting .NET Framework 2.0 or earlier, a better approach is to mark the type as static. In this manner, you avoid having to declare a private constructor to prevent the class from being created.

When to Suppress Warnings

Suppress a warning from this rule only if the type is designed to be inherited. The absence of the sealed modifier suggests that the type is useful as a base type.

Example of a Violation

Description

The following example shows a type that violates the rule.

Code

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

Fix with the Static Modifier

Description

The following example shows how to fix a violation of this rule by marking the type with the static modifier.

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

CA1053: Static holder types should not have constructors