एक ऑपरेटर को एक चर

Question

में स्टोर करें क्या एक ऑपरेटर को एक चर के अंदर स्टोर करने का कोई तरीका है? मैं इस (छद्म कोड) की तरह कुछ करना चाहता हूँ:

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

कुछ इस तरह सी # में मौजूद है:

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

मैं तो इतना की तरह इस विधि कह सकते हैं?

Answer 1

मुझे ऐसा कुछ लगता है। आप ऑपरेटर को परिभाषित नहीं करते हैं, लेकिन एक फ़ंक्शन (लैम्ब्डा) जो आपके लिए परिवर्तन करता है।

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+1); 
MyLoop(60, 10, x => x-1); 

Answer 2

कुछ उपयोग Func<int, int> op तरह

या स्ट्रिंग के लिए सेशन के प्रकार बदलने के लिए, तो मूल्य की जाँच करें और यह के अनुसार निर्माण अपने लूप के लिए:

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

आप ऑपरेटरों को नियमित तरीकों से लपेट सकते हैं और आप से प्रतिनिधियों।

Answer 4

Function delegate का उपयोग करें;

एक विधि एक पैरामीटर है और प्रकार TResult पैरामीटर द्वारा निर्दिष्ट की एक मान देता है कि समाहित।

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

यहाँ एक 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

मैं एक अलग दृष्टिकोण की कोशिश की, एक वर्ग है कि ऑपरेटरों को परिभाषित करता है का उपयोग करते हुए और प्रतिबिंब द्वारा एक्सेस करने वाले - यानी आप तारों के रूप में अपने ऑपरेटरों स्टोर कर सकते हैं। यह रिलेशनल ऑपरेटरों के लिए भी अनुमति देता है।

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