Question

我有条件让我们假设Animal = {Dog,Cat,Elephant}

现在我想用if中的条件（不是简单的for循环）创建一个for循环，在这个for循环中我根据动物类型做了一些代码，例如：

for(int i=0;i<100;i++)
{
  if(some conditions on i)
  {
   for(int j =0;j<100;j++)
   {
     if(some condition on j)
     {
       switch(animaltype)
       {  
         case Dog: //call function 1
         case Cat: //call function 2
         case Elephant: //call function 3
       }
     }
   }
  }
}

因此，对于大循环的情况下的性能优化，我在for循环之外创建了switch-case，所以代码变成了这样：

switch (animaltype)
{
case Dog :
    for(int i=0;i<100;i++)
    {
      if(some conditions on i)
      {
       for(int j =0;j<100;j++)
       {
         if(some condition on j)
         {
           //call function 1
         }
       }
      }  
    }
//-------------
case Cat :
    for(int i=0;i<100;i++)
    {
      if(some conditions on i)
      {
       for(int j =0;j<100;j++)
       {
         if(some condition on j)
         {
           //call function 2
         }
       }
      }  
    }
//----------------------
case Elephant :
    for(int i=0;i<100;i++)
    {
      if(some conditions on i)
      {
       for(int j =0;j<100;j++)
       {
         if(some condition on j)
         {
           //call function 3
         }
       }
      }  
    }
}

问题在于我重复了3次代码（或案例数量），这违反了软件设计的一次且仅一次原则。

我试图传递一个委托但我应该调用的3个函数有不同的参数，有人能告诉我这个案例的一个简洁的解决方案吗？

修改我的意思是“不同的论点”，他们不会采用相同数量的论点。例如：

function1(string s,int age)
function2(float height,bool CanMove)
function3(int legs,string name,string place)

Answer 1

尝试这样的事情：

void ExecuteLoop(Func callback)
{
    for(int i=0;i<100;i++)
    {
        if(some conditions on i)
        {
            for(int j =0;j<100;j++)
            {
                if(some condition on j)
                {
                    callback();
                }
            }
        }  
    }
}

switch (animaltype)
{
case Dog:
    ExecuteLoop(dogCallback);
    break;
case Cat:
    ExecuteLoop(catCallback);
    break;
case Elephant:
    ExecuteLoop(elephantCallback);
    break;
}

这将允许您将循环合并到方法中，同时改变实际执行的内容。目前还不清楚你什么时候说：

...但我应该调用的3个函数有不同的参数......

你的意思是什么我假设有两件事之一：

您打算调用的三种方法将不同的值作为参数传递。

或

您打算调用的三种方法有不同的数字传递给它们。

无论哪种方式，您都可以通过以前的解决方案来解决这个问题。像这样：

switch (animaltype)
{
case Dog:
    ExecuteLoop(() => { dogCallback(1, 2, 3); });
    break;
case Cat:
    ExecuteLoop(() = > { catCallback( "argument 1", "arg 2" ); });
    break;
case Elephant:
    ExecuteLoop(() => { elephantCallback(i, j, k); });
    break;
}

这使用不接受任何参数的lambdas（因此匹配ExecuteLoop方法的要求），但调用接受任意数量的变量类型参数的方法。

Answer 2

我试图传递一个委托但我应该调用的3个函数有不同的论点，谁能告诉我一个简洁的解决方案情况？

创建3个函数，这些函数不带任何调用现有函数的参数。例如......

Func HandleDog = ()=>{function1(param1, param2);};
Func HandleCat = ()=>{function2(param1);};

Answer 3

为了扩展罗伯特和威廉提供的答案，我个人觉得这个更干净：

        Action animalMethod;

        switch (animalType)
        {
            case Dog:
                animalMethod = new Action(() => CallMethod1(animal as Dog));
                break;
            case Cat:
                animalMethod = new Action(() => CallMethod1(animal as Dog));
                break;
            case Elephant:
                animalMethod = new Action(() => CallMethod1(animal as Dog));
                break;
            default:
                throw new Exception("Unknown Animal");
        }

        for (var i = 0; i < 100; i++)
        {
            if (some conditions on i)
            {
                for (var j = 0; j < 100; j++)
                {
                    if (some condition on j)
                    {
                        animalMethod();
                    }
                }
            }
        }

避免为不同的代码执行重复循环

3 个答案: