[Solved]How to create groups of methods? Useful to create and modify code at runtime.

Code (CSharp):

1. using UnityEngine;
2.  
3. public class temp : MonoBehaviour {
4.  
5.     public delegate void Operation();
6.  
7.     public void methodA(int integer){
8.    
9.         Debug.Log("method A: "+integer);
10.    
11.     }
12.  
13.     public void methodB(string word){
14.    
15.         Debug.Log("method B: "+word);
16.    
17.     }
18.  
19.     public static Operation CreateOperation(Operation iteration, int repetitions){
20.  
21.         return delegate() { //or Lambda expression: return () => {
22.  
23.             int count = repetitions;
24.             Operation method = iteration;
25.             for(int i = 0; i<count; i++) method();
26.  
27.         };
28.  
29.     }
30.  
31.     public static Operation CreateOperation(params System.Action[] iterations){
32.  
33.         return delegate() {
34.  
35.             System.Action[] actions = iterations;
36.             foreach(System.Action action in actions) action.Invoke();
37.  
38.         };
39.  
40.     }
41.  
42.     void Start(){
43.  
44.         //Operation by Anonimous method
45.         Operation methodsGroup1 = CreateOperation (() => methodA(1),() => methodB("word"));
46.         Operation methodsGroup2 = CreateOperation (() => methodA(10),5);
47.         methodsGroup1();
48.         methodsGroup2();
49.  
50.     }
51.  
52. }
53.  

I've managed to create methods group using the generic delegate Operation and lambda functions.

But I would like to add methods as argument, without using lambda functions, amb use indeterminate number of parameters as does StartCoroutine of Unity.

This is useful to create and modify code at runtime.

 

You would need to use C# delegates

 

I use C# delegate, because Operation is a delegate.

Use delegate is constraint about number of parameters used in method.

I am searching information about using indeterminate number of parameters in methods.

Exactly how does Unity StartCoroutine where we pass methods with any number and type of parameters.

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. public class temp : MonoBehaviour {
5.  
6.     IEnumerator myMethod1(string str){
7.  
8.         Debug.Log(str);
9.         yield return null;
10.  
11.     }
12.  
13.     IEnumerator myMethod2(int number, string str){
14.  
15.         Debug.Log(number+str);
16.         yield return null;
17.  
18.     }
19.  
20.     void Start(){
21.  
22.         StartCoroutine(myMethod1("word"));
23.         StartCoroutine(myMethod2(10,"ball"));
24.  
25.     }
26.  
27. }
28.  

The only solution I've found is to use lambda functions.

 

Up on this one. I'm interested to see a solution too.

 

You are miss understanding how StartCoroutine works it isn't taking a function with arguments as a arg but the return of that function which is of the type IEnumerator.

What you want yo do isn't really possible without lambda, or using delegates. Though you can use delegates with generics to make them work for multiple arugmeant types.

Unless your using a dynamically typed language like python what you want can't be done in the way you want.

 

No problem, you can convert methods from void to IEnumerator and add yield instruction.

Do you know as StartCoroutine works? Please send example with IEnumerator methods or complete CreateAction method from next code to return System.Action:

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. public class temp : MonoBehaviour {
5.  
6.     public IEnumerator myMethod1(string str){
7.  
8.         Debug.Log("method1");
9.         yield return null;
10.  
11.     }
12.  
13.     public IEnumerator myMethod2(float number,string str,bool active){
14.  
15.         Debug.Log("method2");
16.         yield return null;
17.  
18.     }
19.  
20.     public System.Action CreateAction(params IEnumerator[] methodsArray){
21.  
22.         return () =>{
23.  
24.             IEnumerator[] methods = methodsArray;
25.             foreach(IEnumerator method in methods){
26.  
27.                 //How to invoke the method with the same arguments values
28.                 //as StartCoroutine?
29.  
30.             }
31.  
32.         };
33.  
34.     }
35.  
36.     void Start(){
37.  
38.         System.Action methodGroup = CreateAction(myMethod1("one"),myMethod2(1f,"two",true));
39.         methodGroup();
40.  
41.     }
42.  
43. }

I look at example about delegate with params object[] args to indeterminate number of parameter, but need pass all arguments as object, and need pass delegate to method and object[] args array by separate.

Any idea, about StartCoroutine process. Thanks.

 

Finally, I managed to store calling functions without using lambda expression, using IEnumerable (not IEnumerator as StartCoroutine).

Code (CSharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. public class temp : MonoBehaviour {
5.  
6.     public IEnumerable myMethod1(string str){
7.  
8.         Debug.Log(str);
9.         yield return null;
10.  
11.     }
12.  
13.     public IEnumerable myMethod2(int number, string str){
14.  
15.         Debug.Log(number+str);
16.         yield return null;
17.  
18.     }
19.  
20.     System.Action CreateAction(params IEnumerable[] methodsArray){
21.  
22.         return () =>{
23.  
24.             IEnumerable[] methods = methodsArray;
25.             foreach(IEnumerable method in methods){ foreach(IEnumerable run in method); };
26.  
27.         };
28.  
29.     }
30.  
31.     void Start(){
32.  
33.         System.Action methodGroup = CreateAction(myMethod1("one"),myMethod2(1234,"two"));
34.         methodGroup();
35.  
36.     }
37.  
38. }

To invoke IEnumerable methods, use foreach instruction.