C# 将运算符存储在变量中

有没有办法在变量中存储运算符？我想做这样的事情（伪代码）：

---

C#中是否存在类似的东西？

我想是这样的。您不定义运算符，而是定义一个函数（lambda），它为您进行更改

void MyLoop(int start, int finish, Func<int, int> op)
{
    for(var i = start; i < finish; i = op(i))
    {
        //do stuff with i
    }
}

---

使用类似于

Func op

或者将op的类型更改为string，然后检查该值并根据该值构建for循环，如：

void MyLoop(int start, int finish, string op)
{
    if ((op.Equals("++") && (start < finish))
    {
      for(var i = start; i < finish; i++)
      {
          //processMethod(i)
      }
    }
    else if ((op.Equals("--") && (start > finish))
    {
      for(var i = start; i < finish; i--)
      {
          //processMethod(i)
      }
    }
}

void MyLoop（int start、int finish、string op）
{
如果（（操作等于（“+”&&（开始<结束））
{
对于（变量i=start；ifinish））
{
对于（变量i=开始；i<完成；i--）
{
//处理方法（一）
}
}
}

使用

封装具有一个参数并返回值为的方法 TResult参数指定的类型

这是一个。

公共课程{
公共静态void Main（字符串[]args）{
活套（x=>x+1）；
活套（x=>++x）；
//活套（x=>x++）；将无法工作
活套（x=>x*2）；
}
公共静态无效循环器（Func op）{
对于（int i=1；i<10；i=op（i））{
控制台写入线（i）；
}
Console.WriteLine（--------------”；
}
} 

我尝试了一种不同的方法，使用一个定义运算符并通过反射进行访问的类，也就是说，您可以将运算符存储为字符串。 这也允许使用关系运算符

class Program
{
    static void Main(string[] args)
    {
        Operators ops = new Operators();
        object result = ops.Use("LessOrEqual", new object[] {3,2}); // output: False
        Console.WriteLine(result.ToString());

        result =  ops.Use("Increment", new object[] {3}); // output: 4
        Console.WriteLine(result.ToString());
        Console.ReadKey();
    }
}

public class Operators
{
    public object Use(String methodName, Object[] parameters)
    {
        object result;
        MethodInfo mInfo = this.GetType().GetMethod(methodName);
        result = mInfo.Invoke(this, parameters); // params for operator, komma-divided
        return result;
    }


    public bool LessOrEqual(int a, int b)
    {
        if (a <= b)
        {
            return true;
        }
        else
        {
            return false; 
        }  
    }

    public int Increment(int a)
    {
        return ++a;
    }
}

类程序
{
静态void Main（字符串[]参数）
{
运算符ops=新运算符（）；
object result=ops.Use（“LessOrEqual”，新对象[]{3,2}）；//输出：False
Console.WriteLine（result.ToString（））；
result=ops.Use（“增量”，新对象[]{3}）；//输出：4
Console.WriteLine（result.ToString（））；
Console.ReadKey（）；
}
}
公共类操作员
{
公共对象使用（字符串方法名，对象[]参数）
{
客观结果；
MethodInfo mInfo=this.GetType（）.GetMethod（methodName）；
result=mInfo.Invoke（this，parameters）；//运算符的params，komma divided
返回结果；
}
公共房屋出租人平等（内部a、内部b）
{
如果（a？不知道，但对增量参数+1或-1执行相同的操作。或者对lambda Func执行相同的操作，您的循环将如下所示：（int i=start；iMyLoop(15, 45, x => x+1);
MyLoop(60, 10, x => x-1);

void MyLoop(int start, int finish, string op)
{
    if ((op.Equals("++") && (start < finish))
    {
      for(var i = start; i < finish; i++)
      {
          //processMethod(i)
      }
    }
    else if ((op.Equals("--") && (start > finish))
    {
      for(var i = start; i < finish; i--)
      {
          //processMethod(i)
      }
    }
}

void MyLoop(int start, int finish, Func<int, int> op)
{
    for(var i = start; i < finish; i = op(i))
    {
        //do stuff with i
    }
}

MyLoop(15, 45, x => ++x);
MyLoop(60, 10, x => --x);

public class Program {
    public static void Main(String[] args) {
        Looper(x => x + 1);
        Looper(x => ++x);
        //Looper(x => x++); will not works
        Looper(x => x * 2);
    }

    public static void Looper(Func<int, int> op) {
        for (int i = 1; i < 10; i = op(i)) {
            Console.WriteLine(i);
        }
        Console.WriteLine("----------");
    }

} 

class Program
{
    static void Main(string[] args)
    {
        Operators ops = new Operators();
        object result = ops.Use("LessOrEqual", new object[] {3,2}); // output: False
        Console.WriteLine(result.ToString());

        result =  ops.Use("Increment", new object[] {3}); // output: 4
        Console.WriteLine(result.ToString());
        Console.ReadKey();
    }
}

public class Operators
{
    public object Use(String methodName, Object[] parameters)
    {
        object result;
        MethodInfo mInfo = this.GetType().GetMethod(methodName);
        result = mInfo.Invoke(this, parameters); // params for operator, komma-divided
        return result;
    }


    public bool LessOrEqual(int a, int b)
    {
        if (a <= b)
        {
            return true;
        }
        else
        {
            return false; 
        }  
    }

    public int Increment(int a)
    {
        return ++a;
    }
}