Question

我有一个类，我希望类构造函数根据第一个参数的值而变化。

  public class Calc
    {
        public Calc( Operator calcOpr = Operator.Concat, string sourceName, string newString )
        {
            calcOperator = calcOpr;
            sourceType = dataType;
        }

        public Calc( Operator calcOpr = Operator.PadLeft,  int startindex, int  count )
        {
            calcOperator = calcOpr;
            sourceType = dataType;
        }

现在我知道以上是无效的代码，但作为伪代码，它确实显示了我想要实现的目标。
有没有办法让类构造函数根据参数值重载？

编辑：我想这样做，以便在实例化类时所需的参数根据不同的Operator值进行更改。

Answer 1

你可以这样实现：

public class Calc
    {
        public Calc(string sourceName, string newString )
        {
            calcOperator = Operator.Concat;
            sourceType = dataType;
        }

        public Calc(int startindex, int  count )
        {
            calcOperator = Operator.PadLeft;
            sourceType = dataType;
        }
}

Answer 2

示例代码有点偏，因为它们都有不同的签名（第二个参数的字符串vs int）。所以传递和int或字符串已经选择了正确的重载。

当您想要使用相同方法签名的不同行为时，只需打开枚举：

switch(calcOpr){
  case Operator.Concat: 
    calcOperator = calcOpr;
    sourceType = dataType;
    break;

  case Operator.Padleft: 
    calcOperator = calcOpr;
    sourceType = dataType;
    break;

  default: 
    // throw error?

}

修改（编辑）

一个方法有一个固定的签名，所以如果你想让一个构造函数基于运算符创建正确的类型，你就不必传递所有可能的参数。（坏代码）：

public Calc( Operator calcOpr, string sourceName, string newString,  int startindex, int  count )
{
  switch(calcOpr){
    case Operator.Concat: 
       // validate sourceName and newString

    case Operator.Padleft
       // validate startindex and count

}

味道不好。

我想我会选择单独的方法而不是构造函数重载。（静态，所以你可以从类型中调用它们）

public static Calc GetConcat(string SourceName, string newString){
  Class c = new Class();
  c.calcOperator = Operator.Concat;
  c.sourcetype = dataType; //where does this one come from? 
  //etc..
  return c;
}

public static Calc GetPadLeft(int startindex, int  count){
  Class c = new Class();
  c.calcOperator = Operator.PadLeft;
  c.sourcetype = dataType; //where does this one come from? 
  // etc
  return c;
}

此外，您可能希望研究为Concat和PadLeft创建派生类，这些派生类派生自Calc和重载方法/添加特定属性。实际上我认为这就是我要做的事情，但你必须更多地讲述你正在做的事情。

Answer 3

我认为这里使用的好模式是工厂。

CalcFactory允许来电者明确了解Calc的具体目标。

public static class CalcFactory
{
   public static Calc createConcatCalc(string sourceName, string newString)
   {
       // call explicit constructors
   }

   public static Calc createPadLeftCalc(int startindex, int count)
   {
       // call explicit constructors
   }
}

这个工厂可以在内部使用@Roflcoptr's构造函数。

Answer 4

可能是您可以尝试使用可变参数的构造函数。

public class Calc
{
    public Calc( Operator calcOpr, params object[] values)
    {
    switch(op)
    {
    case Op.CONCAT:
        Concat(values[0],values[1]);
    case Op.PADLEFT:
        PadLeft(values[0],values[1],values[2]);
    }
    }

    public void Concat(string str1, string str2)
    {
    }
    public void PadLeft(string str1, int startindex, int  count )
    {
    }

基于参数值重载方法？

4 个答案: