CODEWITHSUNDEEP
c#enumsresharperbit-manipulation
B. Clay Shannon-B. Crow Raven
B. Clay Shannon-B. Crow Raven

Reputation: 10297

What is the reason for marking an enum with the [Flags] attribute?

We recently ported an old C# app from Visual Studio 2003 to Visual Studio 2010.

In searching for things to clean up in the code, I ran Resharper on it, and it tells me (oodles of times), "Bitwise operation on enum which is not marked by [Flags] attribute"

e.g., here is a bit of code that it "flags" (no pun intended) with that message:

~DuckbillConverter()
{
    //stop running thread
    if((this.Status & ConvertStatus.Running) == ConvertStatus.Running)
        this.Stop();
}

I assume that this code is working as is; so what would be the benefit (or, even more importantly, any possible side effects) of decorating ConvertStatus.Running with the [Flags] attribute, as R# recommends?

UPDATE

Answer to Jon Skeet:

public enum ConvertStatus
{
    /// <summary>
    /// The thread is not running, there are no manual conversions or purges and no errors have occurred.
    /// </summary>
    Stopped = 0x0,
    /// <summary>
    /// The thread is running and will automatically convert all sites for both file types.
    /// </summary>
    Running = 0x1,
    /// <summary>
    /// A data conversion is currently taking place.
    /// </summary>
    Converting = 0x2,
    /// <summary>
    /// A data purge is currently taking place.
    /// </summary>
    Purging = 0x4,
    /// <summary>
    /// An error has occurred.  Use the LastError property to view the error message.
    /// </summary>
    Error = 0x8
}

Upvotes: 5

Views: 4717

Answers (2)

Preston Guillot
Preston Guillot

Reputation: 6724

Resharper isn't recommending that ConvertStatus.Running receive an attribute, but the entire ConvertStatus enum.

From MSDN, FlagsAttribute is described as:

Indicates that an enumeration can be treated as a bit field; that is, a set of flags.

Since you are using bitwise operations on an enum that isn't indicated to actually be usable as a bit field, R# is warning you that your code may have unintended effects at run time. Using the [Flags] attribute itself doesn't guarantee that the implementation of the enum is actually consistent with the values expected for a bit field, but it does create a contract that the outside world should expect it to be.

Upvotes: 8

Yuriy Faktorovich
Yuriy Faktorovich

Reputation: 68737

It tells the client of the enum that it is indeed Flags. Also you can see Microsoft's example in how it modifies ToString().

Upvotes: 1

Related Questions