Question

我需要做的是创建一个我需要的灵活逻辑结构。

班级是这样的：

public class myclass {
  public Action myaction;
  public int actionparams;
  public string label;

  public void myactionfunction() {
    //do void parameter action
  }

  public void myactionfunction(int myparam) {
    //do one parameter action
  }

  public void myactionfunction(int myparam, int myparam2) {
    //do two parameter action
  }
}

我面临的问题是我将使用这个类，其中'myaction'可以任意不需要或多达六个参数。由于需要为每个要支持的参数定义'Action'，我当然可以定义尽可能多的'myactions'，我希望参数可以用，但这并不理想，因为我需要在那里硬连接参数类型。 / p>

我希望有一种方法可以“简单地”重新分配myaction的类型，以便以某种方式我可以做类似的事情

myaction.type = Action<string,int,int>; //i know this looks bad, but should give the idea

我已阅读有关委托声明的内容，但无法确定是否有办法将它们用于我的目的。

感谢。

Answer 1

你可以这样做：

public void myactionfunction(params object[] prms)
{
    int[] intArray = (int[])prms;
    //do what ever you need to do...
}

这也允许您为每个动作传递不同的参数类型：

public void myactionfunction(params object[] prms)
{
    if (myAction == ???)
    {
        string param1 = (string)prms[0];
        //use string as first param
    }
    else
    {
        int param1 = (int)prms[0];
        //use int as first param.
    }
    //do what ever you need to do...
}

可以这样调用：

myactionfunction();
myactionfunction(1);
//and also
myactionfunction(1,2,3,4,5,6,7,8,9,10);

Answer 2

尝试使用optional参数

public void myactionfunction(int myparam, int myparam2 = 0, int myparam3 = 0) {
...
}


void Test()
{
    myactionfunction(5); // Will call myactionfunction(5, 0, 0)
    myactionfunction(5, 10) // Will call myactionfunction(5, 10, 0)
    myactionfunction(1, myparam3: 7) // Will call myactionfunction(1, 0, 7)
}

Answer 3

不，你不能。但是，您可以使用捕获，使所有内容都为Action，即：

public void myactionfunction() {
    myaction = () => DoSomethingWithoutParameters();
}

public void myactionfunction(int myparam) {
    myaction = () => DoSomethingWithOneParameter(myparam);
}

public void myactionfunction(int myparam, int myparam2) {
    myaction = () => DoSomethingWithTwoParameters(myparam, myparam2);
}

如果这些实际上代表默认值，则使用默认值！

public void SomeMethod(int x = 123, int y = 456) {
    myaction = () => Foo(x, y);
}

可以通过以下任何一种方式调用：

SomeMethod();
SomeMethod(1);
SomeMethod(1, 2);
SomeMethod(x: 1);
SomeMethod(y: 2);
SomeMethod(x: 1, y: 2);
SomeMethod(y: 2, x: 1);

Answer 4

关于更改操作，您可以使用泛型，但遗憾的是，您无法将Action定义为约束...因此它有点开放。

public class MyClass<TAction> 
{
    public TAction Action{get;set;}   
}

然后可以使用（对于带有1个字符串＆amp; 2 int参数的Action）：

var c = new MyClass<Action<string,int,int>>();

然后，您可以使用

分配Action

c.Action = (s,i1,i2) => Console.WriteLine("Params were: {0}, {1},{2}",s,i1,i2);

实例：http://rextester.com/DUI63303

在C＃中重新分配或替换变量的类型

4 个答案: