ansaurus

Question

Answer 1

+6 A:

Something like this?

public static void MyMethod(Flags flag)
{
    // Define action-lookup
    var actionsByFlag = new Dictionary<Flags, Action>
    {
        { Flags.p1, DoSomething},
        { Flags.p2, DosomethingElse},
        { Flags.p3, DosomethingElseAgain},
        { Flags.p4, DosomethingElseAgainAndAgain},
    };

    // Find applicable actions
    var actions = actionsByFlag.Where(kvp => (flag & kvp.Key) == kvp.Key)
                               .Select(kvp => kvp.Value);

    //Execute applicable actions
    foreach (var action in actions)
       action();
}

EDIT: If the order of actions are important, an OrderBy clause may be required.

Ani 2010-10-02 18:26:08

In C# 4.0 you can use `dict.Where(kv => flag.HasFlag(kv.Key))`

Callum Rogers 2010-10-02 18:30:57

I like that @Ani, Dictionary and LINQ. Thanks to @Gabe and @Callum Rogers for mentioning new C# 4.0 feature.

kofucii 2010-10-02 18:34:45

Good answer, but define action-lookup *outside* the method.

Caspar Kleijne 2010-10-02 18:35:44

Caspar: The action lookup may require state that's only available inside that method. If not, though, it should be defined outside the method.

Gabe 2010-10-02 18:43:44

@Callum Rogers: Thanks, that's a good point.

Ani 2010-10-02 18:51:13

This is nice, but, to be honest, I think this is harder to read than the simple series of tests and methods. This version requires that the maintaining developer understand a number of intermediate-level concepts and (of lesser concern), it takes considerably longer to execute. As long as the logic for each flag case is delegated to helper methods, I think the initial implementation is actually quite clean.

Dan Bryant 2010-10-02 18:53:44

@Dan Bryant: I agree with you; my answer actually has more code than the initial implementation. I do think the dictionary approach is more readable after you've seen the pattern once, though. I would use it if a) performance were not a concern b) there were several (many more than 4 anyway) flags.

Ani 2010-10-02 18:59:42

Answer 2

+3 A:

Here's a variation on Ani's answer:

public static void MyMethod(Flags flag) 
{ 
    // Define action-lookup 
    var dict = new Dictionary<Flags, Action> 
    { 
        { Flags.p1, DoSomething}, 
        { Flags.p2, DosomethingElse}, 
        { Flags.p3, DosomethingElseAgain}, 
        { Flags.p4, DosomethingElseAgainAndAgain}, 
    }; 

    // Find applicable actions 
    var actions = from value in Enum.GetValues(typeof(Flags))
                  where flag.HasFlag(value)
                  select dict[value];

    //Execute applicable actions 
    foreach (var action in actions)
       action(); 
}

The important difference here is that it iterates over the defined values in the enumeration rather than the entries in the dictionary. That way if you add a new flag to the enum without adding it to the dictionary, you will get an exception when you try to use the new flag. And it always iterates in order of the flags.

Gabe 2010-10-02 18:38:59

ansaurus

tags:

views:

answers:

Bitwise flags and Switch statement?

related questions