Home Library Learn Samples Downloads Support Community Forums
MSDN Library
Development Tools and Languages
Visual Studio 2012
Application Development in Visual Studio
Quality and Diagnostic Tools
Analyzing Application Quality
Analyzing Managed Code Quality
Code Analysis for Managed Code Warnings
Design Warnings
CA1000: Do not declare static members on generic types
CA1001: Types that own disposable fields should be disposable
CA1002: Do not expose generic lists
CA1003: Use generic event handler instances
CA1004: Generic methods should provide type parameter
CA1005: Avoid excessive parameters on generic types
CA1006: Do not nest generic types in member signatures
CA1007: Use generics where appropriate
CA1008: Enums should have zero value
CA1009: Declare event handlers correctly
CA1010: Collections should implement generic interface
CA1011: Consider passing base types as parameters
CA1012: Abstract types should not have constructors
CA1013: Overload operator equals on overloading add and subtract
CA1014: Mark assemblies with CLSCompliantAttribute
CA1016: Mark assemblies with AssemblyVersionAttribute
CA1017: Mark assemblies with ComVisibleAttribute
CA1018: Mark attributes with AttributeUsageAttribute
CA1019: Define accessors for attribute arguments
CA1020: Avoid namespaces with few types
CA1021: Avoid out parameters
CA1023: Indexers should not be multidimensional
CA1024: Use properties where appropriate
CA1025: Replace repetitive arguments with params array
CA1026: Default parameters should not be used
CA1027: Mark enums with FlagsAttribute
CA1028: Enum storage should be Int32
CA1030: Use events where appropriate
CA1031: Do not catch general exception types
CA1032: Implement standard exception constructors
CA1033: Interface methods should be callable by child types
CA1034: Nested types should not be visible
CA1035: ICollection implementations have strongly typed members
CA1036: Override methods on comparable types
CA1038: Enumerators should be strongly typed
CA1039: Lists are strongly typed
CA1040: Avoid empty interfaces
CA1041: Provide ObsoleteAttribute message
CA1043: Use integral or string argument for indexers
CA1044: Properties should not be write only
CA1045: Do not pass types by reference
CA1046: Do not overload operator equals on reference types
CA1047: Do not declare protected members in sealed types
CA1048: Do not declare virtual members in sealed types
CA1049: Types that own native resources should be disposable
CA1050: Declare types in namespaces
CA1051: Do not declare visible instance fields
CA1052: Static holder types should be sealed
CA1053: Static holder types should not have constructors
CA1054: URI parameters should not be strings
CA1055: URI return values should not be strings
CA1056: URI properties should not be strings
CA1057: String URI overloads call System.Uri overloads
CA1058: Types should not extend certain base types
CA1059: Members should not expose certain concrete types
CA1060: Move P/Invokes to NativeMethods class
CA1061: Do not hide base class methods
CA1062: Validate arguments of public methods
CA1063: Implement IDisposable correctly
CA1064: Exceptions should be public
CA1065: Do not raise exceptions in unexpected locations
CA2210: Assemblies should have valid strong names
Expand Minimize
This topic has not yet been rated - Rate this topic

CA1028: Enum storage should be Int32

Visual Studio 2012

TypeName

EnumStorageShouldBeInt32

CheckId

CA1028

Category

Microsoft.Design

Breaking Change

Breaking

The underlying type of a public enumeration is not System.Int32.

An enumeration is a value type that defines a set of related named constants. By default, the System.Int32 data type is used to store the constant value. Even though you can change this underlying type, it is not necessary or recommended for most scenarios. Note that no significant performance gain is achieved by using a data type that is smaller than Int32. If you cannot use the default data type, you should use one of the Common Language System (CLS)-compliant integral types, Byte, Int16, Int32, or Int64 to make sure that all values of the enumeration can be represented in CLS-compliant programming languages.

To fix a violation of this rule, unless size or compatibility issues exist, use Int32. For situations where Int32 is not large enough to hold the values, use Int64. If backward compatibility requires a smaller data type, use Byte or Int16.

Suppress a warning from this rule only if backward compatibility issues require it. In applications, failure to comply with this rule usually does not cause problems. In libraries, where language interoperability is required, failure to comply with this rule might adversely affect your users.

The following example shows two enumerations that do not use the recommended underlying data type.

C#
VB
Copy 
using System;

namespace DesignLibrary
{
   [Flags]
   public enum Days : uint
   {
      None        = 0,
      Monday      = 1,
      Tuesday     = 2,
      Wednesday   = 4,
      Thursday    = 8,
      Friday      = 16,
      All         = Monday| Tuesday | Wednesday | Thursday | Friday
   }

   public enum Color :sbyte
   {
      None        = 0,
      Red         = 1,
      Orange      = 3,
      Yellow      = 4
   }
}

The following example fixes the previous violation by changing the underlying data type to Int32.

C#
VB
Copy 
using System;

namespace Samples
{
    [Flags]
    public enum Days : int
    {
        None        = 0,
        Monday      = 1,
        Tuesday     = 2,
        Wednesday   = 4,
        Thursday    = 8,
        Friday      = 16,
        All         = Monday| Tuesday | Wednesday | Thursday | Friday
    }

    public enum Color : int
    {
        None        = 0,
        Red         = 1,
        Orange      = 3,
        Yellow      = 4
    }
}
Did you find this helpful?
(1500 characters remaining)
© 2013 Microsoft. All rights reserved.