Question

我想知道我应该如何编写以下代码？我想要一个基类，并让其中一个派生类覆盖基类中的一个方法。但是我需要为要覆盖的方法使用不同的签名（更复杂的是，该方法被隐藏在循环中）。

我应该如何正确构建以下代码以完成相同的覆盖具有不同签名的方法？ （摆脱抽象声明是可以的）

abstract class ClassBase
{
    public void LoopThroughStuff(int i)
    {
        for (i = 0; i < 10; i++)
        {
            //DO A BUNCH OF STUFF
            var k = (something determined in loop) //THIS IS USED IN Class2's DoSomething(i,k)

            DoSomething(i); //THIS NEEDS TO BE OVERRIDDEN IN Class2 WITH ADDITIONAL PARAMETER, WHICH I KNOW CAN'T BE DONE

            //DO A BUNCH OF STUFF
        }
    }

    public virtual void DoSomething1(int x)
    {
        //DO STUFF
    }
}

public class Class1 : ClassBase
{

}

public class Class2 : ClassBase
{
    public override void DoSomething1(int j, int k) //I KNOW THIS CAN NOT BE DONE
    {
        //DO STUFF
    }
}

Answer 1

有很多选择。这是一个：使用泛型。

abstract class ClassBase<T>
{
    public abstract void DoSomething(T args);
}

public class Class1 : ClassBase<Class1Args>
{
    public void DoSomething(Class1Args args);
}

public class Class1Args
{
    public int x;
}

public class Class2 : ClassBase<Class2Args>
{
    public void DoSomething(Class2Args args);
}

public class Class2Args
{
    public int j;
    public int k;
}

Answer 2

像下面的代码那样使用基类，它使用Function overloading类型的Polymorphism。可以找到基本OOP的起始参考here

abstract class ClassBase
{
   public virtual void LoopThroughStuff(int i)
   {
      for (i = 0; i < 10; i++)
      {
        //DO A BUNCH OF STUFF

        DoSomething(i);

        //DO A BUNCH OF STUFF
       }
   }

   public virtual void DoSomething1(int x)
   {
      //DO STUFF
   }

   public virtual  void DoSomething1(int j, int k)
   {
     //you can keep this empty, as you will override it in Class2
   }

 }


public class Class2 : ClassBase
{

  public override void LoopThroughStuff(int i)
  {
     for (i = 0; i < 10; i++)
     {
        //DO A BUNCH OF STUFF
        // set k here as you like

        DoSomething(i,k);

       //DO A BUNCH OF STUFF
     }
  }
  public override void DoSomething1(int j, int k) 
  {
    //DO STUFF
  }
}

Answer 3

继承对你正在做的事情可能有点过分。反过来思考，尝试一种功能性的风格。

从数组或列表（任何类型）开始，然后使用带有lamba或Func对象的Select方法，该对象将“映射”或对数组的每个元素执行转换并返回新的数组或列表。

string [] array = {"element1", "element2"};

Func<string, string> DoSomething = (x) => x.ToUpper();

var result = array.Select(DoSomething);

或更简洁：

var result = array.Select(x => x.ToUpper());

应如何编写抽象类以使用其他参数覆盖方法

3 个答案: