Easy way to get all Enum values in c#

Question

I've tried a little Program... I want to run a program and see all method names in c# class... Here is the code

class Program
{
    public int adf()
    {
        return 0;
    }
    static void Main(string[] args)
    {

        foreach (MethodInfo mInfo in typeof(Program).GetMethods(BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
        {
            Console.WriteLine(mInfo.Name);
        }
       Console.ReadKey();
    }
    private void bdf()
    {
        Console.WriteLine("Dg");
    }
}

It's work fine, in result I've got this

 adf
 main
 bdf

Now , I want to pass to GetMethods function only one parameter and get result... I don't think it's a good way to pass 5 parameters with 'binary or(|)' ... In BindingFlags Enum is 19 fields and what it will be if I want to pass 18 parameters xD How can I do it passing only one value?

Here Is Enum

 public enum BindingFlags
{
    Default = 0,
    IgnoreCase = 1,
    DeclaredOnly = 2,
    Instance = 4,
    Static = 8,
    Public = 16,
    NonPublic = 32,
    FlattenHierarchy = 64,
    InvokeMethod = 256,
    CreateInstance = 512,
    GetField = 1024,
    SetField = 2048,
    GetProperty = 4096,
    SetProperty = 8192,
    PutDispProperty = 16384,
    PutRefDispProperty = 32768,
    ExactBinding = 65536,
    SuppressChangeType = 131072,
    OptionalParamBinding = 262144,
    IgnoreReturn = 16777216,
  }
}

I think it's very interesting and helpful question...

You can _edit_ the question and add to it. Better than putting it in a comment. — Oded, Aug 05 '11 at 10:45
There is no ability. You want to return more than 1 values using only 1 value. Or just write a static method to not repeat this over and over. — Sergey Metlov, Aug 05 '11 at 10:46
I've answered with a method (could easily be generic function) to get a value that is all flags of an enum, you could then subtract values from that if its easier. — George Duckett, Aug 05 '11 at 10:49

George Duckett · Answer 1 · 2011-08-05T11:23:37.407

6

Code below should get a value containing all flags (could easily be made into a generic method), you can then do AllFlags & ~FlagToRemove to get all but one flag.

AllFlags = (EnumFlagType)Enum.GetValues(typeof(EnumFlagType))
                             .Cast<int>().Aggregate((acc, next) => acc | next);

[Flags]
enum TestEnum { one = 1, two = 2, three = 4, four = 8 };

void Main()
{

    var AllFlags = (TestEnum)Enum.GetValues(typeof(TestEnum))
                             .Cast<int>().Aggregate((acc, next) => acc | next);

    Console.WriteLine(AllFlags); // Prints "one, two, three, four"

    Console.WriteLine(AllFlags & ~two); // Prints "one, three, four"
}

edited Aug 05 '11 at 11:23

answered Aug 05 '11 at 10:40

George Duckett

31,770
9
95
162

2

I dont think calling `Sum` is good idea here. This will fail if you have 'masks' or composite values defined in the enumeration. You probably want a `BitwiseOr()` in the place of `Sum()`. – leppie Aug 05 '11 at 10:53
It's not a good way... Imagine that I want to write only 9 of 19 enum values xD – Chuck Norris Aug 05 '11 at 12:16
1

My imagination isn't that good! In that case go with @Artur's answer, i just gave my answer as it keeps type safty and demonstrates a few different ideas. – George Duckett Aug 05 '11 at 18:39

score 4 · Accepted Answer · answered Aug 05 '11 at 10:38

4

Pay attantion at the body of BindingFlags enumeration, all the values are power of 2. So binary or just calculates sum of provided integer values. In order to pass all flags just send the sum of all int values. In order to pass only some values just send binary integer with 1 in the corresponding position of the flag which needs to be passed. Please see code below.

BindingFlags flag = (BindingFlags)Convert.ToInt32("0000010010000101010", 2)

for your example must be

BindingFlags flag = (BindingFlags)Convert.ToInt32("111110", 2)

and when we print the flag we have a

DeclaredOnly, Instance, Static, Public, NonPublic

and you can get metods

            Type t = typeof(Program);
            MethodInfo[] mi = t.GetMethods(flag);

You right, it is a really interesting question.

answered Aug 05 '11 at 10:38

Artur Keyan

7,643
12
52
65

The only issue I see is that of readability - there is no way to tell what flags are actually used without knowing the Enum values. – Oded Aug 05 '11 at 10:47
Yes, this is really great way... All I want is this! – Chuck Norris Aug 05 '11 at 10:49
1

All the answers so far are viable *except for this one*. It'll work but doing it like this is just asking for trouble down the line. A single misplaced `1` or `0` is all it will take to break stuff, and all just to save a bit of typing. – LukeH Aug 05 '11 at 11:48
1

when you have 19 flags, then this saving is not a little bit, and this helps to understanding work with this flags – Artur Keyan Aug 05 '11 at 11:58
1

@Artur: Yes, but setting up a few constants for common usages, for example, is going to be more readable and less breakable. I wouldn't know whether to laugh or cry if I saw something like this in production code. – LukeH Aug 05 '11 at 12:08

score 3 · Answer 3 · answered Aug 05 '11 at 10:38

3

Write static method:

public static class BindingFlagsHelper
{
    public static BindingFlags GetAllMethods()
    {
        return 
            BindingFlags.NonPublic | 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | 
            BindingFlags.Instance | BindingFlags.Static;
    }
}

answered Aug 05 '11 at 10:38

Sergey Metlov

25,747
28
93
153

1

I want easy and short way... Your way is same as mine, I don't see any differences)))) – Chuck Norris Aug 05 '11 at 10:40

score 3 · Answer 4 · answered Aug 05 '11 at 10:40

You can use a variable to hold the interesting flags and pass that through:

BindingFlags myFlags = BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;

foreach (MethodInfo mInfo in typeof(Program).GetMethods(myFlags))
{
     Console.WriteLine(mInfo.Name);
}

score 2 · Answer 5 · answered Aug 05 '11 at 10:41

You won't be passing 5 parameters, you'll be passing only one int when the bitwise ors are done executing, you could put unlimited flags and '|' them and only one sizeof(int) parameter will be passed. You could make precomputed values with

const int my_val = flag_1|flag_3|flag_5;

Easy way to get all Enum values in c#

5 Answers5