C# 如何将这4个函数转换为一个函数？

您可以使用枚举：

enum StatusRouter{Stop=0，Start，Resume，Suspect}

public bool StartSelectedRouter()
{
    for (int i = 0; i < m_listPlatforms.Count; i++)
    {
        if (m_listPlatforms[i].IsCheked)
            m_listPlatforms[i].Start();
    }
    return false;
}
public bool ResumeSelectedRouter()
{
    for (int i = 0; i < m_listPlatforms.Count; i++)
    {
        if (m_listPlatforms[i].IsCheked)
            m_listPlatforms[i].Resume();
    }
    return false;
}
public bool SuspendSelectedRouter()
{
    for (int i = 0; i < m_listPlatforms.Count; i++)
    {
        if (m_listPlatforms[i].IsCheked)
            m_listPlatforms[i].Suspend();
    }
    return false;
}
public bool StopSelectedRouter()
{
    for (int i = 0; i < m_listPlatforms.Count; i++)
    {
        if (m_listPlatforms[i].IsCheked)
            m_listPlatforms[i].Stop();
    }
    return false;
}

public bool StartSelectedRouter（）
{
for（int i=0；i
提取重复部分、循环，并传递要执行的操作：

public bool DoSelectedRouter(StatusRouter statusRouter)
{
    for (int i = 0; i < m_listPlatforms.Count; i++)
    {
        if (m_listPlatforms[i].IsCheked)
        {
            switch(statusRouter)
            {
               case StatusRouter.Stop:
                 m_listPlatforms[i].Stop();
                 break;
               case StatusRouter.Resume:
                 m_listPlatforms[i].Resume();
                 break;       
                 .......
            }
        }            
    }
    return false;
}

public bool DoSelectedRouter（状态路由器状态路由器）
{
for（int i=0；i

当然，您始终可以放弃枚举并传递要执行的操作的函数委托。
您可以将DoAction复制到函数中，但这样更具可读性

public bool DoActionSelectedRouter(StatusRouter action)
{
    for (int i = 0; i < m_listPlatforms.Count; i++)
    {
        if (m_listPlatforms[i].IsCheked)
        {
            DoAction(m_listPlatforms[i], action);
        }
    }
    return false;
}

private void DoAction(Platform platform,StatusRouter  action)
{
     switch(action){
         case(StatusRouter.Stop):
         {
                platform.Stop();
                break;
         }
         case(StatusRouter.Start):
         {
                platform.Start();
                break;
         }
         case(StatusRouter.Suspend):
         {
                platform.Suspend();
                break;
         }
         case(StatusRouter.Resume):
         {
                platform.Resume();
                break;
         }
     }
}

public bool DoActionSelectedRouter（状态路由器操作）
{
for（int i=0；i
您可以传入一个lambda，定义要对每个元素执行的操作

比如：

public bool ChangeSelectedRouterState(Action<Router> action) 
{
    for (int i = 0; i < m_listPlatforms.Count; i++)
    {
        if (m_listPlatforms[i].IsCheked)
            action(m_listPlatforms[i]);
    }
    return false;
}

您需要将我为我的答案发明的类型
路由器
替换为您正在处理的特定类型。
您可以通过将操作传递给执行所需操作的方法来使用策略模式（假设您的类被称为平台）-例如：

ChangeSelectedRouterState(r => r.Stop());

    public bool ActionSelectedRouter(Action<Platform> action)
    {
        for (int i = 0; i < m_listPlatforms.Count; i++)
        {
            if (m_listPlatforms[i].IsCheked)
                action(m_listPlatforms[i]);
        }
        return false;            
    }

public bool Action selectedrouter（动作动作）
{
for（int i=0；i
首先，我将单个路由器的状态设置分解为一个单独的功能。我想让这个函数成为
路由器
类的成员

然后我会写一个助手函数，让我检查所有路由器。最后是一个函数，该函数对它们中的每一个调用
SetRouterStatus
函数

这样，每个功能都有一个单独的职责，可以重用

您的代码还存在一些其他问题：
被选中
应该被
选中
并且
可疑
应该被
挂起

为什么函数返回的
bool
总是错误的

public void SetSelectedRoutersStatus(StatusRouter status)
{
    foreach(var router in GetCheckedRouters())
    {
        SetRouterStatus(router);
    }
}

IEnumerable<Router> GetCheckedRouters()
{
    return m_listPlatforms.Where(router=>router.Checked);
}

void SetRouterStatus(Router router,StatusRouter status)
{
     switch(status)
     {
         case(StatusRouter.Stop):
         {
                router.Stop();
                break;
         }
         case(StatusRouter.Start):
         {
                router.Start();
                break;
         }
         case(StatusRouter.Suspend):
         {
                router.Suspend();
                break;
         }
         case(StatusRouter.Resume):
         {
                router.Resume();
                break;
         }
         default:
           throw new NotSupportedException("Invalid StatusRouter");
     }
}

public void setselectedrouterstatus（状态路由器状态）
{
foreach（GetCheckedRouters（）中的var路由器）
{
SetRouterStatus（路由器）；
}
}
IEnumerable GetCheckedRouters（）
{
返回m_listplations.Where（router=>router.Checked）；
}
void SetRouterStatus（路由器、状态路由器状态）
{
开关（状态）
{
案例（StatusRouter.Stop）：
{
router.Stop（）；
打破
}
案例（StatusRouter.Start）：
{
router.Start（）；
打破
}
案例（StatusRouter.Suspend）：
{
router.Suspend（）；
打破
}
案例（StatusRouter.Resume）：
{
router.Resume（）；
打破
}
违约：
抛出新的NotSupportedException（“无效状态路由器”）；
}
}

（根据@peer的回答）
如何将这4个函数转换为一个？顺便说一句，我怀疑“可疑”实际上应该是“Suspend”@digEmAll，是的，是的，谢谢@Uwe Keim，不，这不是家庭作业。为什么投反对票？这是最接近我的答案。@peer:break不是函数，所以没有圆括号；）他在回答时在哪里使用了Linq？@Jan，对不起，我不明白那个评论？这个问题没有说明是否使用LINQ，我的答案也没有使用LINQ。你的答案上有一条评论，比如“我不能在这个项目中使用LINQ”。很明显，它后来被移除了。
public void SetSelectedRoutersStatus(StatusRouter status)
{
    foreach(var router in GetCheckedRouters())
    {
        SetRouterStatus(router);
    }
}

IEnumerable<Router> GetCheckedRouters()
{
    return m_listPlatforms.Where(router=>router.Checked);
}

void SetRouterStatus(Router router,StatusRouter status)
{
     switch(status)
     {
         case(StatusRouter.Stop):
         {
                router.Stop();
                break;
         }
         case(StatusRouter.Start):
         {
                router.Start();
                break;
         }
         case(StatusRouter.Suspend):
         {
                router.Suspend();
                break;
         }
         case(StatusRouter.Resume):
         {
                router.Resume();
                break;
         }
         default:
           throw new NotSupportedException("Invalid StatusRouter");
     }
}