Coding mode C #

public void DoSomeTasks( )
{
 if (CheckSomeState()==true) return;
 DoTaskOne();
 if (CheckSomeState()==true) return;
 DoTaskTwo( );
 if (CheckSomeState()==true) return;
 DoTaskThree();
 if (CheckSomeState()==true) return;
 DoTaskFour(); 
)

private void DoTasksWhile(Func condition, Action[] tasks)
{
 foreach (var task in tasks)< br /> {
 if (condition.Invoke()==false) break;
 task.Invoke();
 }
}

public void DoSomeTasks()
{
 var tasks = new Action[] {
 {()=DoTaskOne()}, 
 {()=DoTaskTwo()},
 {()=DoTaskThree()},
 {()=DoTaskFour()}

 }

 DoTasksWhile(()=>CheckSomeState(), tasks);
}

private void DoTasksWhile(Func predicate, IEnumerable tasks)
{
 foreach (var task in tasks)
 {
 if ( !predicate())
 return;
 task();
 }
}

public static void DoWhile(this IEnumerable actions,Func predicate)
{
 foreach (var action in actions) 
 {
 if (!predicate())
 return;
 actions();
 }
}

tasks.DoWhile(() => CheckSomeState());

I was reviewing the code a few days ago I encountered some code that looks like this.

public void DoSomeTasks()
{
 if (CheckSomeState()==true ) return;
 DoTaskOne();
 if (CheckSomeState()==true) return;
 DoTaskTwo();
 if (CheckSomeState()==true) return;
 DoTaskThree();
 if (CheckSomeState()==true) return;
 DoTaskFour(); 
}

As the number of tasks increases, the code will eventually have higher cyclomatic complexity, and it feels wrong to me.

I propose to solve this The solution to the problem is.

private void DoTasksWhile(Func condition, Action[] tasks)
{
 foreach (var task in tasks )
 {
 if (condition.Invoke()==false) break;
 task.Invoke();
 }
}

Use like this

public void DoSomeTasks()
{
 var tasks = new Action[] {
 {()=DoTaskOne() },
 {()=DoTaskTwo()},
 {()=DoTaskThree()},
 {()=DoTaskFour()}

 }< br />
 DoTasksWhile(()=>CheckSomeState(), tasks);
}

Does anyone have any suggestions to make the code more readable?

I have refactored your implementation

private void DoTasksWhile(Func  predicate, IEnumerable tasks)
{
 foreach (var task in tasks)
 {
 if (!predicate())
 return;< br /> task();
 }
}

>You don’t need to call delegates. Just execute them
>Don’t compare booleans to true/false ( It’s useless, you can specify a boolean value incorrectly)
>So you only enumerate tasks, IEnumerable is suitable for parameters

You can also create extension methods

public static void DoWhile(this IEnumerable actions,Func predicate)
{
 foreach (var action in actions)
 {
 if (! predicate())
 return;
 actions();
 }
}

The usage is very simple:

tasks.DoWhile(() => CheckSomeState());