Question

我是使用OOP进行编程的新手，我正在尝试正确使用继承的概念。

以下是我尝试的代码（Link Here）

public class Base
{
    //Type?
    public abstract static object Adapter();              

    public static DataTable GetWOCost(DateTime Date, string WO)
    {
        Application.UseWaitCursor = true;
        DataTable dt = new DataTable();

        try
        {
            //Cast?
            dt = Adapter().GetDataByWO(WO, Date);
            Application.UseWaitCursor = false;
            return dt;

        } catch (Exception)
        {
            return null;
        }
    }
} 

public class Materiel : Base
    {
        static AllieesDBTableAdapters.CoutMatTableAdapter Adapter()
        {
            return new AllieesDBTableAdapters.CoutMatTableAdapter();        
        }
    }

    public class Labor : Base
    {
        static AllieesDBTableAdapters.CoutLaborTableAdapter Adapter()
        {
            return new AllieesDBTableAdapters.CoutLaborTableAdapter();
        }
    }

首先，我的所有代码都在Material类中。但是我必须添加第二个相同的类，但是对于不同的SQL适配器。我尝试了不同的东西，但上面的代码有一个很大的问题。

由于类型正在改变，我使用了对象，但没有强制转换就无法工作。但是因为我不知道它将是什么类型，有两个或更多类具有GetWOCost方法但使用不同适配器的正确方法是什么？

也许我应该改用.NET 4.0并使用动态对象？

编辑：此外，似乎有抽象和静态的问题，所以我不能在我的方法GetWOCost（）上使用static修饰符，而没有Adapter（）的实例（在基类中）。看起来复制粘贴会更容易，但我试图找出正确的方法。

Answer 1

在这种情况下你应该做的是针对接口进行编程，接口定义契约，用于你想要用Adapter对象做什么。如果您的实现类不共享公共接口，则可以为它们创建一个。

然后你可以创建这个接口的不同实现;并在每个子类中重写适配器方法以返回正确的接口实现。

你应该摆脱你的静态方法，因为多态类型的整个想法是你可以得到不同的实例，它们以不同的方式做同样的事情。

在代码中，这可能看起来像这样（简化）：

public interface IAdapter 
{
    DataTable GetWOCost();  // Implementors must have a method with this signature
}

public class Base 
{
    public abstract IAdapter Adapter();  

    // Methods that use IAdapter instances here.
}

class Materiel : Base 
{
    public override IAdapter Adapter() { return new CoutMatTableAdapter(); } 
}

class Labor : Base 
{
    public override IAdapter Adapter() { return new CoutLaborTableAdapter(); }
}

然后您只需要让不同的适配器实现您的新界面，例如：

public class CoutLaborTableAdapter : IAdapter 
{
    public DataTable GetWOCost() { /* implementation */ }
}

Answer 2

好的，我确实让你的解决方案工作，GetDataByWO＆amp; amp; GetWOCost。你没有使用正确的。

    public interface IAdapter
{
    DataTable GetDataByWO(string WO, DateTime Date);   
}

public abstract class Base
{
    public abstract IAdapter Adapter(); 

    public DataTable GetWOCost(DateTime Date, string WO)
    {
        Application.UseWaitCursor = true;
        DataTable dt = new DataTable();

        try
        {
            dt = Adapter().GetDataByWO(WO, Date);
            Application.UseWaitCursor = false;
            return dt;

        } catch (Exception)
        {
           return null;
        }
    }
}

public class Materiel : Base
{
    public override IAdapter Adapter()
    {
        return new CoutMatTableAdapter();        
    }
}

public class Labor : Base
{
    public override IAdapter Adapter()
    {
        return new CoutLaborTableAdapter();
    }
}

public class CoutMatTableAdapter: IAdapter
{
    public DataTable GetDataByWO(string WO, DateTime Date)
    {
        AllieesDBTableAdapters.CoutMatTableAdapter adpt = new AllieesDBTableAdapters.CoutMatTableAdapter();
        return adpt.GetDataByWO(WO, Date);
    }
}

public class CoutLaborTableAdapter : IAdapter
{
    public DataTable GetDataByWO(string WO, DateTime Date)
    {
        AllieesDBTableAdapters.CoutLaborTableAdapter adpt = new AllieesDBTableAdapters.CoutLaborTableAdapter();
        return adpt.GetDataByWO(WO, Date);
    }
}

现在找出为什么worker类抛出异常（生成SQL部分）。所以似乎抽象和静态不能很好地结合在一起（我可以理解为什么，但是我的方法静态会很棒）

使用具有不同变量（不同类型）的继承方法

2 个答案: