I like to write enum or integer to pass option to my methods. Is there a pattern or a method in C# to check if an (int 1,2,4,8,...) option is true or false. I think it should easily be possible via binary functions.
class Program
{
public enum Option
{
Option_A = 1,
Option_B = 2,
Option_C = 4,
Option_D = 8,
}
static void Main(string[] args)
{
int activeOption = 5; // Means I activeted the Option_A and Option_C
if (IsOption(activeOption, Option.Option_A)) { /*do work*/ }
if (IsOption(activeOption, Option.Option_B)) { /*do work*/ }
if (IsOption(activeOption, Option.Option_C)) { /*do work*/ }
if (IsOption(activeOption, Option.Option_D)) { /*do work*/ }
}
private static bool IsOption(int activeOption, Option option)
{
/*Evaluate if IsOption is true or false*/
throw new NotImplementedException();
}
}
EDIT
Am I limited the number of options that I can create like this?
For Java and C#, there are only methods. For C, there are only functions.
Yes, there are. Lazy initialization, singleton, object pool, object state etc.
A pattern program in C generally contains nested loops where the outer loop controls the number of rows, and the inner loop controls the data in each row containing the contents to be printed.
A method is a code block that contains a series of statements. A program causes the statements to be executed by calling the method and specifying any required method arguments.
Use bitwise AND to check if the bits in option
are set in activeOption
. You also need to make both parameters the same type so the operator will work (you are checking the bits in an Option
bitmask anyway):
private static bool IsOption(Option activeOption, Option option)
{
return (activeOption & option) == option;
}
Since your enum contains flags (or if you prefer, is a bitfield), you should add a FlagsAttribute
to it:
[Flags]
public enum Option
{
Option_A = 1,
Option_B = 2,
Option_C = 4,
Option_D = 8,
}
And then, checking is typically done with the bitwise and operator. A cast will also be needed, because you are using an int
variable.
if(((Option)activeOption & Option.Option_A) != Option.Option_A) //...
If you want to encapsulate this nastiness away, check out the article linked in Smudge202's answer. If you are running .NET 4, you don't even need to do that: check sehe's answer.
But you should really try using a variable of type Option
directly, and combine the options with the bitwise or operator:
Option activeOption = Option.Option_A | Option.Option_C;
Of course using this scheme limits the number of options you can create. If you leave it as is, you can only create 32 different options, because an int
(the default underlying type of an enum) has only 32-bits. If you use a long
you can have 64 different options:
[Flags]
public enum Option : long
{
Option_A = 1,
Option_B = 2,
Option_C = 4,
Option_D = 8,
// blah blah
}
However, if you need an arbitrary number of options, it's probably time to change strategies. You could make a custom type that behaves like an enum, but you'll probably be better off with just a regular, non-flags enum, and a HashSet<Option>
.
public enum Option
{
Option_A = 1, // notice the sequential values now
Option_B = 2,
Option_C = 3,
Option_D = 4,
}
HashSet<Option> options = new HashSet<Option> { Option.Option_A, Option.Option_C };
if(options.Contains(Option.Option_A)) // ...
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With