Lưu trữ toán tử trong một biến

Question

Có cách nào để lưu trữ toán tử bên trong biến không? Tôi muốn làm một cái gì đó như thế này (pseudo code):

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

Sau đó tôi có thể gọi phương pháp này như sau:

MyLoop(15, 45, ++); 
MyLoop(60, 10, --); 

Có một cái gì đó như thế này tồn tại trong C#?

Answer 1

Tôi cho rằng một cái gì đó như thế này. Bạn không xác định toán tử, nhưng một hàm (lambda) thực hiện thay đổi cho bạn.

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

Sau đó tôi có thể gọi phương pháp này như sau:

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

Answer 2

sử dụng một cái gì đó giống như Func<int, int> op

hoặc thay đổi kiểu của op để chuỗi, sau đó kiểm tra giá trị và theo đó xây dựng của bạn đối với vòng lặp như:

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) 
     } 
    } 
} 

Answer 3

Bạn có thể kết hợp toán tử với các phương thức thông thường và u se đại biểu.

Answer 4

Sử dụng Function delegate;

Đóng gói phương thức có một tham số và trả về giá trị loại được chỉ định bởi tham số TRESult.

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

Sau đó;

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

Đây là DEMO.

Answer 5

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("----------"); 
    } 

} 

Answer 6

Tôi đã thử một cách tiếp cận khác, sử dụng lớp xác định toán tử và truy cập thông qua sự phản chiếu - tức là bạn có thể lưu trữ toán tử dưới dạng chuỗi. Điều này cũng cho phép các toán tử quan hệ.

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; 
    } 
}