一个代码结构设计的问题
我有这样两个类

public class Operat1
{
  DataTable dataInfo = null;
  
  public Operat1()
  {
     InitDataTable();
  }

  private void InitDataTable()
  {
   //构建dataInfo 结构（列）
  }
  
  public void Dosm(List<A> list,string name)
  {
     //构建dataInfo 数据
  }
}

public class Operat2
{
  DataTable dataInfo = null;
  
  public Operat2()
  {
     InitDataTable();
  }

  private void InitDataTable()
  {
   //构建dataInfo 结构（列）
  }
  
  public void Dosm(List<B> list,string name)
  {
     //构建dataInfo 数据
  }
}

如上所示，但是随着项目的不但扩展，可能出现Operat3,4,5.....
这个结构该怎么设计，更易于扩展？
请大神指点。 设计 扩展性
[解决办法]
好多相似的地方啊 直接父类可能代码少点
但是用继承的话 必须提前设计好
万一后来出了问题 以前全得改- -
[解决办法]
Operat<T>

public class Operat<T>
{
  DataTable dataInfo = null;
   
  public Operat2()
  {
     InitDataTable();
  }
 
  private void InitDataTable()
  {
   //构建dataInfo 结构（列）
  }
   
  public void Dosm(List<T> list,string name)
  {
     //构建dataInfo 数据
  }
}

------解决方案--------------------

public abstract class Operat
{
  DataTable dataInfo = null;

  protected abstract void InitDataTable();
 
  protected abstract void Dosm<T>(List<T> list, string name);
}

之后每个类继承下并实现相应的方法就可以了
[解决办法]
public abstract class BaseOperat
{
public DataTable dataInfo = null;
public BaseOperat()
{
InitDataTable();
}

protected abstract void InitDataTable();

public abstract void Dosm<T>(List<T> list, string name);
}
[解决办法]

引用:

Quote: 引用:

public abstract class BaseOperat
{
public DataTable dataInfo = null;
public BaseOperat()
{
InitDataTable();
}

protected abstract void InitDataTable();

public abstract void Dosm<T>(List<T> list, string name);
}

如果这样 那子类在实现
public abstract void Dosm<T>(List<T> list, string name);
这个方法的时候 仍然是实现了泛型的方法
public void Dosm<T>(List<T> list, string name)
{
......
}

而不是我想要的
public void Dosm<A>(List<A> list, string name)
{
......
}
这种用具体类型为参数的方法啊

把T加到抽象类上面
然后集成的时候把A替换T就是了