Home Library Learn Samples Downloads Support Community Forums
MSDN Library
.NET Development
.NET Framework 3.0
Tools
Development Tools
FxCop
FxCop Warnings
Design Warnings
Abstract types should not have constructors
Assemblies should have valid strong names
Avoid empty interfaces
Avoid excessive parameters on generic types
Avoid namespaces with few types
Avoid out parameters
Collections should implement generic interface
Consider passing base types as parameters
Declare event handlers correctly
Declare types in namespaces
Default parameters should not be used
Define accessors for attribute arguments
Do not catch general exception types
Do not declare protected members in sealed types
Do not declare static members on generic types
Do not declare virtual members in sealed types
Do not declare visible instance fields
Do not expose generic lists
Do not hide base class methods
Do not nest generic types in member signatures
Do not overload operator equals on reference types
Do not pass types by reference
Enum storage should be Int32
Enumerators should be strongly typed
Enums should have zero value
Exceptions should be public
Generic methods should provide type parameter
ICollection implementations have strongly typed members
Implement IDisposable correctly
Implement standard exception constructors
Indexers should not be multidimensional
Interface methods should be callable by child types
Lists are strongly typed
Mark assemblies with AssemblyVersionAttribute
Mark assemblies with CLSCompliantAttribute
Mark assemblies with ComVisibleAttribute
Mark attributes with AttributeUsageAttribute
Mark enums with FlagsAttribute
Members should not expose certain concrete types
Move P/Invokes to NativeMethods class
Nested types should not be visible
Override methods on comparable types
Override operator equals on overloading add and subtract
Properties should not be write only
Provide ObsoleteAttribute message
Replace repetitive arguments with params array
Static holder types should be sealed
Static holder types should not have constructors
String URI overloads call System.Uri overloads
Types should not extend certain base types
Types that own disposable fields should be disposable
Types that own native resources should be disposable
URI parameters should not be strings
URI properties should not be strings
URI return values should not be strings
Use events where appropriate
Use generic event handler instances
Use generics where appropriate
Use integral or string argument for indexers
Use properties where appropriate
Validate arguments of public methods
Expand Minimize
2 out of 3 rated this helpful - Rate this topic

Static holder types should not have constructors

.NET Framework 2.0

TypeName

StaticHolderTypesShouldNotHaveConstructors

CheckId

CA1053

Category

Microsoft.Design

Breaking Change

Breaking

A public or nested public type declares only static members and has a public or protected default constructor.

The constructor is unnecessary because calling static members does not require an instance of the type. Also, because the type does not have non-static members, creating an instance does not provide access to any of the type's members.

To fix a violation of this rule, remove the default constructor or make it private.

NoteNote

Some compilers automatically create a public default constructor if the type does not define any constructors. If this is the case with your type, add a private default constructor to eliminate the violation.

Do not exclude a warning from this rule. The presence of the constructor suggests that the type is not a static type.

The following example shows a type that violates this rule. Note that there is no default constructor in the source code. When this code is compiled into an assembly, the C# compiler will insert a default constructor, which will violate this rule. To correct this, declare a private constructor.

C#
Copy 
using System;

namespace DesignLibrary
{
   public class NoInstancesNeeded
   {
      // Violates rule: StaticHolderTypesShouldNotHaveConstructors.
      // Uncomment the following line to correct the violation.
      // private NoInstancesNeeded() {}

      public static void Method1() {}
      public static void Method2() {}
   }
}
Did you find this helpful?
(1500 characters remaining)

Community Additions

ADD
© 2013 Microsoft. All rights reserved.
|
Site Feedback
© 2013 Microsoft. All rights reserved.