Enum variable with flags

Question

1.00/5 (1 vote)

See more:

I assign flags to an enum variable and want:
1.- Retrieve their values without iterating on the Enum typeof and check if the variable has the flag with HasFlag. That is, I want to iterate over the Variable retrieving its Flags. For example, if I assign flags to a variable and stop execution and check the variable with Debug, its flags appear.

2.- Retrieve the values in the Order in which I have assigned them. Suppose I want to do something in the order in which I have entered the flags.

C#

namespace Name_Enum_Test
{
    #region Inicializacion
    [System.Flags]
    public enum Enum_Test
    {   Undefined  = 0,
        One        = 1,
        Two        = 2,
        Tree       = 4
    }
    public class Cls_Enum_Test
    {
    #endregion

    #region Enum. Test
        // --------------------------------------------------
        // ENUM. TEST.
        // Ejemplo:Name_Enum_Test.Cls_Enum_Test.Fcn_Test(Name_Enum_Test.Enum_Test.Two | Name_Enum_Test.Enum_Test.One)
        // --------------------------------------------------
        // [System.Diagnostics.DebuggerStepThroughAttribute]
        public static void Fcn_Test(Name_Enum_Test.Cls_Enum_Test Enum_Test)
        {  
            try
            {   foreach(System.Enum MyEnum in Enum_Test)
                {
                }
            }
            catch(System.Exception ErrorExcp){}
        }
    }
    #endregion
}

What I have tried:

in this function.in this function.in this function.

Posted 6-Oct-21 18:29pm

Member 14890678

Updated 7-Oct-21 5:43am

PIEBALDconsult

v2

Add a Solution

4 solutions

Solution 2

An enum is stored as an integer, so you can cast between them at will.
So you can use the binary AND, OR, XOR, and NOT operators to check your values very easily:

C#

Enum_Test et = Enum_Test.One | Enum_Test.Two;
if ((et & Enum_Test.Two) == 0)
{
    Console.WriteLine("Two is not set");
}
else
{
    Console.WriteLine("Two is set");
}

Posted 6-Oct-21 23:02pm

OriginalGriff

Solution 4

1. Yes and no. You may have to iterate the defined values, but you definitely don't want to do so many times during the execution of the application, especially in a loop.
What I prefer to do is to populate a Dictionary once at the startup, in a static class or similar, then access the Dictionary as needed.

2. If you really want to, then you'll have to develop support for it. Maybe your class can use a Stack of enum values rather than a single value. When a value is set, you push the new value onto the Stack. Then you can walk the Stack to determine the order of set values.

Posted 7-Oct-21 4:11am

PIEBALDconsult

Solution 5

Advice; I think you need to "ground" your understanding of what Enums are, and what they are intended to be used for with some research and careful experimentation. Here's some great tutorials: [^], [^]

Caution: Enums are single/special purpose entities that are compiled into an internal form: you have to use reflection on Type (expensive methods) to access its internals ... compared to other structures. Enums conveniently embody the idea of a set of values related by magnitude.

I can see no reason why anyone would want/need to determine whether an Enum had the Flags attribute at run-time ... if I saw code performing that test, I'd say there is a problem in the strategy/structure being used.

As Piebald noted above, the Flags Attribute only affects certain Enum functions: ToString, Enum.Parse, and Enum.IsDefined.

If an Enum has #0 CustomAttributes, it is not flagged; but an Enum could have one, or more, CustomAttributes, and not be flagged.

You can determine if an Enum has Flags at run-time:

public bool HasflagsAttribute(Type enm)
{
    return enm.IsDefined(typeof(FlagsAttribute), false);
}

// test
//    enum test1
//    {
//        notokay = 1,
//        okay = 2,
//        good = 4
//    }
//
//    [Flags]
//    enum test2
//    {
//        notokay = 1,
//        okay = 2,
//        good = 4
//    }
//
//    bool test1flagged = HasflagsAttribute(typeof(test1));
//    bool test2flagged = HasflagsAttribute(typeof(test2));

Posted 7-Oct-21 5:43am

BillWoodruff

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard Deeming · Accepted Answer · 2021-10-06T22:59:00

1) You can't. The closest you can get is to use Enum.GetValues combined with Enum.HasFlag:

C#

public static class EnumExtensions
{
    public static IEnumerable<T> ListFlags<T>(this T value) where T : struct, Enum
    {
        // Check that this is really a "flags" enum:
        if (!Attribute.IsDefined(typeof(T), typeof(FlagsAttribute)))
        {
            yield return value;
            yield break;
        }
        
        T[] values = (T[])Enum.GetValues(typeof(T));
        for (int index = 0; index < values.Length; index++)
        {
            T flag = values[index];
            if (!flag.Equals(default(T)) && value.HasFlag(flag))
            {
                yield return flag;
            }
        }
    }
}

2) You can't. The Enum is simply a numerical value representing the combined values of the specified flags. It does not maintain any information about the order in which they were added.

For a literal assignment, the compiler doesn't even preserve the combining operation. Code such as:

C#

Enum_Test value = Enum_Test.One | Enum_Test.Two;

is compiled to:

C#

Enum_Test value = (Enum_Test)3;

If the order in which the flags were set is important to you, then an Enum is the wrong tool to use.