Question

我不确定我所询问的是否可能，所以请耐心等待。

目前我有多个功能，每个功能都有相同的循环位和不同的动作。

我想要一个函数，其主要目的是遍历列表中的某些条目，并根据调用者执行不同的操作。

我的一个解决方案是使用switch / if块和来自调用者的唯一变量来确定操作。但是，我更多地考虑调用函数以及如何传递应该对每个条目执行的操作。

Answer 1

也许你的函数可以将Action<T>作为参数，每个调用者都可以提供自己的操作作为参数？

public void LoopOperation(Action<MyType> action)
{
    foreach(MyType myObject in myCollection)
    {
         action(myObject);
    }
}

您可以像下面这样称呼它：

LoopOperation(o => Console.WriteLine(o.ToString()));

或者可能如下：

LoopOperation(o => o.SaveToDatabase());

或者您要执行的任何其他操作。

Answer 2

您可以使用某种形式的lamba（谓词）来执行类似

的操作

public void dosomethingfunciton(Func<YourType, ResultType> func)
{
     foreach(vat item in List)
     {
        var result = func(item);
     }

}

Answer 3

我想用你似乎要达到的“使用代表”回答来回答这个问题......但是我想到了自己......为什么？它过于复杂，特别是如果你永远不会在其他一些例程中重复使用'action'代码。

所以，我要说点KISS的话：

enum MyActions
{
   Action1,
   Action2,
   Action3
}

public DoStuff(MyActions theAction, Itemlist theList)
{
   foreach (SomeItem in theList)
   {
       // do any common stuff

       switch (theAction)
       {
           case Action1:
              //Action 1 specific stuff
              break;
           case Action2:
              //Action 2 specific stuff
              break;
           case Action3:
              //Action 3 specific stuff
              break;
       }
   }
}

我知道......基本......但很简单，并且完成了工作。

Answer 4

您可以简单地向函数添加一个参数，用于确定必须采取的操作。

public enum CallerType {
    RedCaller, GreenCaller, BlueCaller
}

public MyResultType MyFunction(CallerType callerType)
{
    switch (callerType) {
        case CallerType.RedCaller:
            DoRedCallerStuff();
            break;
        case CallerType.GreenCaller:
            DoGreenCallerStuff();
            break;
        case CallerType.BlueCaller:
            DoBlueCallerStuff();
            break;
        default:
            DoDefaultStuff();
            break;
    }
}

Answer 5

您可以将操作传递给该功能。查看代理Action，Action<T>等，以查看有关如何将“操作”传递给函数的一些示例。

Answer 6

对于稍微替代的策略，您可以通过interitance实现此目的：例如

public abstract class BaseLooper<TItem>
{
    public void DoLoop (List<TItem> list)
    {
        foreach (TItem item in list)
        {
            DoLoopAction(item);
        }
    }

    protected abstract void DoLoopAction(TItem item);
}

public class BlueLooper
    : BaseLooper<BlueClass>
{
    protected overrides DoLoopAction (BlueClass item)
    {
        ...Do Stuff
    }
}

注意：我没有运行这个，所以可能有奇怪的错误，但我相信你明白了！

这样做的好处是循环中执行的操作可能非常混乱 - 其他调用，要引入子类的属性等等。

具有不同动作的相同功能取决于呼叫者

6 个答案: