Is there way to use extension methods to achieve below implementation in C#?

I have a method which does something like shown below :

// check if bits 6,7,8 are zero
if ((num >> 5) != 0)
{
    //do some thing
    return false;
}
        
// check if bits 2 ,3,4 are zero
if ((num & 0x0E) != 0)
{
     //do something
     return false;
}

// check if bit 1 is 1
if ((num & 1) != 1)
{
    //dosomething
    return false;
 }

and now I want to add extension method like :

   num
   .arebitsset((6,7,8) ,(do some action and return from method if false , if true allow chaining))
   .arebitsset(2,3,4) , <same as above>)
   .......

While I know the logic for bitset checking, but I need to know how to return from the method or allow chaining based on true/false outcome.

Is it possible by using func? I am not sure.

NOTE : I have 80 such conditions to be tested below , so is it good to write 80 if conditions , certainly not , so i need some compact form

You could write extension methods like this:

public static class BitSetExtensions
{
    private static bool AreBitsSet(int i, int[] bits)
    {
        // you already have this
    }

    public static (int value, bool valid) CallActionIfBitsSet(this int value, int[] bits, Action action)
    {
        return CallActionIfBitsSet((value, true), bits, action);
    }

    public static (int value, bool valid) CallActionIfBitsSet(this (int value, bool valid) data, int[] bits, Action action)
    {
        if (data.valid)
        {
            data.valid = AreBitsSet(data.value, bits);

            if (data.valid) action();
        }

        return data;
    }
}

Then you can chain them like this:

int num = 5;

num.CallActionIfBitsSet(new[] {1, 3, 5}, () =>
    {
        /* action */
    })
    .CallActionIfBitsSet(new[] {2, 3, 4}, () =>
    {
        /* other action */
    })
    .CallActionIfBitsSet(new[] {2, 3, 6}, () =>
    {
        /* other action */
    });

I am not a big fan personally because I don't think your interface gets easier this way compared to traditional if, but it would work.

There is one more way to achieve something that should be ok for you.

You can define structure as in code below. Using pattern matching and basing on monads, specifically on flatMap function with signature that you can see below, it is possible to create a chain of functions that would stop executing completelty transparent to the caller, based only on what happens inside those functions.

You can read more about it if you search for Rust's Option or Haskell's Maybe. Those types (sum types) that those languages use are not however native to C#, they need some effort to implement.

For example in code below only
> 1 2 2 I got None!

Will be displayed to console as third call to FlatMap breaks the chain returning None.

This can be used to your particular problem, however it can be also used to a lot of other problems.

By inspecting type of final value you can learn if the chain of calls was succesfull.

The pro of this approach is that all ifs are completely transparent to the caller.

class Program
{
    static void Main()
    {
        var a = new Option<int>.Some(1);
        var result = a.FlatMap<int>(i => { Console.WriteLine(i); return new Option<int>.Some(i + 1); })
         .FlatMap<int>(i => { Console.WriteLine(i); return new Option<int>.Some(i); })
         .FlatMap<int>(i => { Console.WriteLine(i); return new Option<int>.None(); })
         .FlatMap<int>(i => { Console.WriteLine(i); return new Option<int>.Some(i); });

        switch (result)
        {
            case Option<int>.Some some:
                Console.WriteLine("I got Some!");
                break;
            case Option<int>.None none:
                Console.WriteLine("I got None!");
                break;
            default:
                throw new InvalidOperationException();
        }

    }
}

public abstract class Option<T>
{
    public class Some : Option<T>
    {
        public Some(T data)
        {
            Data = data;
        }

        public T Data;
    }

    public class None : Option<T> { }

    public Option<T> FlatMap<T>(Func<T, Option<T>> action)
    {
        switch (this)
        {
            case Option<T>.Some some:
                return action(some.Data);
            case Option<T>.None none:
                return none;
            default:
                throw new InvalidOperationException();
        }
    }
}

You cannot return from the middle of a method chain.
You could invent a way to mimick such a behaviour but it would be not so nice, as one reading the method call alone would not suspect such a behaviour.

Since you also asked for this in comment, an alternative method if you want to avoid the 80 "if"s not using extension methods would be to have a list of pair of test and action to perform if the test is successful, test each in a foreach loop.
I don't think you would gain any readability, but there would be only one "if" in your code.

Using a simple class like this one (alternatively, ValueTupple could be used to get rid of this class):

public class Test
{
	public Func<int, bool> Condition { get; set; }
	public Func<int, bool> Operation { get; set; }
}

You could do:

	var Tests = new List<Test>
	{
		new Test
		{
			Condition = num => (num >> 5) != 0,
			Operation = num => { // Do stuff}
		},
		new Test
		{
			Condition = num => (num & 0x0E) != 0,
			Operation = num => { // Do other stuff}
		}
        // Add all your 80+ tests here
	};

// Then use a single if:
foreach (var test in Tests)
{
	if(test.Condition(Number))
	{
		test.Operation(Number);
        // Whatever the test that succeeded was, do here what you need to perform before returning, if needed.
		return false;
	}
}

Without throwing big words like monads around, you can construct an object representing the entire execution plan and then short-circuit it from the inside. It'd be very akin to making your own LINQ method, only instead of enumerating the source and then yielding the results, we need to be able to run the plan or extend it (continue) with another action. Our IExecutable<T> will represent a chain of actions dependent on a parameter of type T that can be executed, returning a status that allows other methods in the chain to modify the control flow as needed. We'll need a unary parameter and parameterless version:

public enum ExecutionResult
{
    RunToCompletion,
    Aborted
}

public interface IExecutable
{
    ExecutionResult Execute();
}

public interface IExecutable<T>
{
    ExecutionResult Execute(T argument);
}

We'll make two (technically three) implementations. First, a SimpleExecutable and SimpleExecutable<T>, that won't do any fancy stuff, just wrap an action and run it.

internal class SimpleExecutable : IExecutable
{
    private readonly Func<ExecutionResult> _action;

    public SimpleExecutable(Func<ExecutionResult> action) => _action = action;

    public ExecutionResult Execute() => _action();
}

internal class SimpleExecutable<T> : IExecutable<T>
{
    private readonly Func<T, ExecutionResult> _action;

    public SimpleExecutable(Func<T, ExecutionResult> action) => _action = action;

    public ExecutionResult Execute(T argument) => _action(argument);
}

Nothing interesting here, now the one you actually want, a ShortCircuitingConditionalExecutable<T>:

internal class ShortCircuitingConditionalExecutable<T> : IExecutable<T>
{
    private readonly Func<T, ExecutionResult> _action;
    private readonly Func<T, bool> _predicate;

    public ShortCircuitingConditionalExecutable(
        Func<T, ExecutionResult> action,
        Func<T, bool> predicate) =>
        (_action, _predicate) = (action, predicate);

    public ExecutionResult Execute(T argument)
    {
        if (!_predicate(argument))
        {
            return ExecutionResult.Aborted;
        }

        _action(argument);
        return ExecutionResult.RunToCompletion;
    }
}

Execute checks the predicate, runs the method if it's true and returns a result signalling whether we should short-circuit the operation.

To make this more handy to use, let's make a few helper extensions:

public static class Executable
{
    public static IExecutable<T> StartWithIf<T>(
        Action<T> action,
        Func<T, bool> predicate) =>
        new ShortCircuitingConditionalExecutable<T>(ReturnCompletion(action), predicate);

    public static IExecutable ContinueWith(this IExecutable source, IExecutable executable) =>
        new SimpleExecutable(ChainIfCompleted(source.Execute, executable.Execute));

    public static IExecutable<T> ContinueWith<T>(this IExecutable<T> source, IExecutable<T> executable) =>
        new SimpleExecutable<T>(ChainIfCompleted<T>(source.Execute, executable.Execute));

    public static IExecutable<T> ContinueWithIf<T>(
        this IExecutable<T> source,
        Action<T> action,
        Func<T, bool> predicate) =>
        source.ContinueWith(new ShortCircuitingConditionalExecutable<T>(ReturnCompletion(action), predicate));

    public static IExecutable BindArgument<T>(this IExecutable<T> source, T argument) =>
        new SimpleExecutable(() => source.Execute(argument));

    private static Func<ExecutionResult> ChainIfCompleted(
        Func<ExecutionResult> action1,
        Func<ExecutionResult> action2) =>
        () =>
        {
            var result = action1();
            return result != ExecutionResult.RunToCompletion ? result : action2();
        };

    private static Func<T, ExecutionResult> ChainIfCompleted<T>(
        Func<T, ExecutionResult> action1,
        Func<T, ExecutionResult> action2) =>
        t =>
        {
            var result = action1(t);
            return result != ExecutionResult.RunToCompletion ? result : action2(t);
        };

    private static Func<T, ExecutionResult> ReturnCompletion<T>(Action<T> action) =>
        t =>
        {
            action(t);
            return ExecutionResult.RunToCompletion;
        };
}

I've omitted a few obvious extensions we could make, but that's rather a lot of code, so maybe a motivating example of this thing in action:

class Program
{
    private static Func<int, bool> AreBitsSet(params int[] bits) => 
       n => bits.All(b => (n & (1 << b)) != 0);

    private static void Print(int n) => Console.WriteLine(n);

    static void Main(string[] args)
    {
        var num1 = (1 << 2) | (1 << 4) | (1 << 5);
        var num2 = num1 | (1 << 7);

        var executable = Executable.StartWithIf(Print, AreBitsSet(2))
            .ContinueWithIf(Print, AreBitsSet(2, 4, 5))
            .ContinueWithIf(Print, AreBitsSet(7));

        var executableNum1 = executable.BindArgument(num1);
        var executableNum2 = executable.BindArgument(num2);

        var program = executableNum1.ContinueWith(executableNum2);

        executable.Execute(num1);
        executable.Execute(num2);
        program.Execute();
    }
}

The first execution prints 52 twice (num1). The second execution prints 180 thrice (num2). The execution of program prints only 52 twice and short-circuits the rest of the execution.

This is not a fully production-ready module, as I've ignored argument validation and there are probably possible optimisations that would avoid some allocations when constructing the execution flow (we're making a lot of delegates). Also, it would be really nice to make this thing more fluent by enabling execution.ContinueWith(action).If(predicate) syntax. It's also terribly overcomplicated, since your use case requires only a very specific execution chain, but what the heck, it was fun writing it up.

Aside: To anyone interested, this is not a monad, but very close so. We would have to replace Execute with something that returns the constructed Action<T> delegate and then write up the appropriate bind function. Then we'd get a monad over Actions of any T, and we could still make Execute into an extension method that gets the delegate and immediately calls it. The BindArgument is a special case of a bind: t => bind(e, f => () => f(t)).

Checking the conditions with an if statement is the most efficient and the easiest to debug. In case of an exception you'll know where to look for the bug. My only suggestion is to get rid of the recurrent return false; statements, by using a single if with multiple else if:

public static bool Execute(int num)
{
    if ((num >> 5) != 0) // check if bits 6, 7, 8 are zero
    {
        // do something
    }
    else if ((num & 0x0E) != 0) // check if bits 2, 3, 4 are zero
    {
        // do something
    }
    else if ((num & 1) != 1) // check if bit 1 is 1
    {
        // do something
    }
    else
    {
        return false; // nothing has been done
    }
    return true; // something has been done
}