If—Else \ If-ElseIf—Else 的随想、改造

最近有一个想法，想把这些If--Else、If-ElseIf-Else，全部换成一条条的Command,然后把这个Command串起来，最后放到CommandList中把它们一锅端了。:)

所以以下就这个想法产物：

先列举一下通常的分支、支叉

static String IfElseIfElse (Int32 conditionParam) {
var result = String.Empty;
if ( conditionParam == 1 ) {
result = "conditionParam1";
}
else if ( conditionParam == 2 ) {
result = "conditionParam2";
}
else {
result = "default";
}
return result;
}

那现在就按照想法、分不同场景来进化Code吧

场景1：根据传统的If-Else进行的改造，只适用传统的True Or Else的操作

声明方法： T ExecuteCommand<T> (IDictionary<Boolean , List<Func<T>>> commandList)

具体代码：

/// <summary>
/// 适用传统的True Or False的操作
/// </summary>
static T ExecuteCommand<T> (IDictionary<Boolean , List<Func<T>>> commandList) {
T t = default ( T );
foreach ( var command in commandList ) {
if ( command.Key ) {
t = command.Value[0] ();
break;
}
else {
t = command.Value[1] ();
break;
}
}
return t;
}

具体应用：

/// <summary>
/// 根据传统的If-Else进行的改造
/// </summary>
static String CommandList (Int32 conditionParam) {

var commandList = new Dictionary<Boolean , List<Func<String>>> ();
{
commandList.Add ( ( conditionParam == 1 ) ,
new List<Func<String>> (){
()=> { return "conditionParam1"; },
()=> { return "-conditionParam1"; }
} );
commandList.Add ( ( conditionParam == 2 ) ,
new List<Func<String>> () {
()=> { return "conditionParam2"; }
} );
}
return ExecuteCommand<String> ( commandList );
}

--------------------------------------------------------------------------------------------------------------------------------------------------

场景2：根据“场景1”缺点，增加了对If-ElseIf-Else的支持

声明方法： T ExecuteCommand<T> (Boolean? condition , Func<T> action)

具体代码：

/// <summary>
/// 适用True And False And Default的操作
/// </summary>
static T ExecuteCommand<T> (Boolean? condition , Func<T> action) {
T t = default ( T );
if ( condition.HasValue ) {
if ( condition.Value ) { t = action (); }
}
else {
t = action ();
}
return t;
}

具体应用：

/// <summary>
/// 增加了对If-ElseIf-Else的支持
/// </summary>
static String CommandFuncList (Int32 conditionParam) {
var commandList = new List<String> (){
ExecuteCommand<String>(( conditionParam ==1 ),
()=> { return "conditionParam1"; }
),
ExecuteCommand<String>(( conditionParam ==2 ),
()=> { return "conditionParam2"; }
),
ExecuteCommand<String>(null,
()=> { return "default"; }
)
};
return commandList.Where ( o => o != null ).First ();
}

--------------------------------------------------------------------------------------------------------------------------------------------------

以上场景都是带返回值，那如何对不同分支、不同那个什么；只想执行方法，一个方法或多个方法，又应该如何处理呢？

场景3：告诉我们还可以这样干

声明方法：List<Action> ExecuteCommand (Boolean? condition , List<Action> action)

具体方法：

/// <summary>
/// 只适用If-Else的方法操作
/// </summary>
static List<Action> ExecuteCommand (Boolean? condition , List<Action> action) {
List<Action> _action = default ( List<Action> );
if ( condition.HasValue ) {
if ( condition.Value ) {
_action = action;
}
}
else {
_action = action;
}
return _action;
}

具体应用：

static void CommandActionList (Int32 conditionParam) {
var commandList = new List<List<Action>> (){
ExecuteCommand(( conditionParam ==1 ),
new List<Action>() { ()=> Write() }
),
ExecuteCommand(( conditionParam ==2 ),
new List<Action>(){
()=> Write(),
()=> WriteAction()
}
)
};
commandList.Where ( o => o != null ).Select ( o => o ).ToList ().ForEach ( o => o.ForEach ( i => i () ) );
}

--------------------------------------------------------------------------------------------------------------------------------------------------

场景4：告诉我们，加上执行步骤，会让我们对分支掌控游刃有余

声明方法：List<Action> ExecuteCommand (ref Boolean execStep , Boolean? condition , List<Action> action)

具体方法：

static List<Action> ExecuteCommand (ref Boolean execStep , Boolean? condition , List<Action> action) {
List<Action> _action = default ( List<Action> );
if ( execStep ) {
if ( condition.HasValue ) {
if ( condition.Value ) {
_action = action;
execStep = false;
}

}
else {
_action = action;
execStep = false;
}
}
return _action;
}

具体应用：

static void CommandActionListWithStep (Int32 conditionParam) {
var execStep = true;
var commandList = new List<List<Action>> (){
ExecuteCommand(ref execStep,( conditionParam ==1 ),
new List<Action>() { ()=> Write() }
),
ExecuteCommand(ref execStep,( conditionParam ==2 ),
new List<Action>(){
()=> Write(),
()=> WriteAction()
}
),
ExecuteCommand(ref execStep,null, new List<Action>(){ ()=> WriteDefault() } )
};

commandList.FindAll ( (p) => { return p != null; } )
.ForEach ( o => o.ForEach ( i => i () ) );
}

static void Write () { Console.Write ( "Hello Command" ); }

static void WriteAction () { Console.Write ( "Hello Action" ); }

static void WriteDefault () { Console.Write ( "Hello Default" ); }

--------------------------------------------------------------------------------------------------------------------------------------------------

最终全部方法执行结果：

static void Main (string[] args) {
Console.Write ( "IfElseIfElse ( 1 )" + IfElseIfElse ( 1 ) );
Console.WriteLine ();
Console.Write ( "IfElseIfElse ( 4 )" + IfElseIfElse ( 4 ) );
Console.WriteLine ();
Console.Write ( "CommandList ( 1 )" + CommandList ( 1 ) );
Console.WriteLine ();
Console.Write ( "CommandList ( 2 )" + CommandList ( 2 ) );
Console.WriteLine ();
Console.Write ( "CommandFuncList ( 1 )" + CommandFuncList ( 1 ) );
Console.WriteLine ();
Console.Write ( "CommandFuncList ( 4 )" + CommandFuncList ( 4 ) );
Console.WriteLine ();
CommandActionList ( 1 );
Console.WriteLine ();
CommandActionList ( 2 );
Console.WriteLine ();
CommandActionListWithStep ( 1 );
Console.WriteLine ();
CommandActionListWithStep ( 4 );
Console.WriteLine ();
}