Question

我有一个C＃类，我想为不同的场景重用它。根据具体情况，某些字段的值需要更改。我正在考虑构建一个抽象基类然后继承。后代类的构造函数将包含新的字段值。像这样：

public abstract Class MyBaseClass
{
   protected string var1;
   protected string var2;
   protected string var3;
   public MyBaseClass()
   {
      var1 = string.empty;
      var2 = string.empty;
      var3 = string.empty;
   }
   public bool myfunc()
   {
       //code to do something with var1...var3
   }
}
  public class myderivedclass: MyBaseClass
 {
    public myderivedclass()
    {
     //constructor for derived class
     base.var1 = "whatever";
     base.var2 = "something";
     base.var3 = "somethingelse";
    }
 }

 public class myotherderivedclass: MyBaseClass
 {
    public myotherderivedclass()
    {
     //constructor for derived class
     base.var1 = "new";
     base.var2 = "newer";
     base.var3 = "newest";
    }
 }

然后我会实例化myderivedclass或myotherderivedclass并调用myfunc之类的函数来完成工作。有没有更好的方法来处理字段中的这些更改，或者这是一个好方法吗？

感谢-你。

Answer 1

我不知道受保护的字段是否真的被认为是一种不好的做法，但在我看来这是一种代码味道。字段通常是实现细节，派生类不应该依赖于其基类的实现细节。

更简洁的方法是将var1，var2和var3更改为虚拟属性，并在派生类中覆盖它们。

public abstract Class MyBaseClass
{
   protected virtual string var1 { get { return ""; } }
   protected virtual string var2 { get { return ""; } }
   protected virtual string var3 { get { return ""; } }

   public bool myfunc()
   {
       //code to do something with var1...var3
   }
}

 public class myderivedclass: MyBaseClass
 {
     protected override string var1 { get { return "whatever"; } }
     protected override string var2 { get { return "something"; } }
     protected override string var3 { get { return "somethingelse"; } }
 }

Answer 2

如果差异仅在初始值，这不是一个好方法。最好在基类中引入一个接受参数的新构造函数。然后在子类中只传递不同的值。

public abstract class MyBaseClass
{
    private string var1;
    private string var2;
    private string var3;

    public MyBaseClass(string var1, string var2, string var3)
    {
        this.var1 = var1;
        this.var2 = var2;
        this.var3 = var3;
    }

    public bool Myfunc()
    {
        //code to do something with var1...var3
    }
}

public class DerivedClass : MyBaseClass
{
    public DerivedClass()
        : base("var1value", "var2value", "var3value")
    {
        //constructor for derived class
    }
}

public class OtherDerivedClass : MyBaseClass
{
    public OtherDerivedClass()
        : base("new", "newer", "newest")
    {
        //constructor for derived class
    }
}

此外，受保护的领域不是很好的做法。如果您需要在子类中访问此成员，最好引入受保护的属性。

public abstract class MyBaseClass
{
    protected string Var1 { get; private set; }
    protected string Var2 { get; private set; }
    protected string Var3 { get; private set; }

    public MyBaseClass(string var1, string var2, string var3)
    {
        this.Var1 = var1;
        this.Var2 = var2;
        this.Var3 = var3;
    }

    public bool Myfunc()
    {
        //code to do something with var1...var3
    }
}

[ ... ] 

public class DerivedClass : MyBaseClass
{
    public DerivedClass()
        : base("var1value", "var2value", "var3value")
    {
        // constructor for derived class
        // can acces protected members here
    }
}

[ ... ]

Answer 3

实现目标的另一种方法是使用interface。它的作用类似于abstract类，但只有方法签名。 interface中的任何内容都必须在继承的类中。

例如：

public interface IMyBaseClass
{
     // Properties for classes
     string MyVar1 {get;set;}
     string MyVar2 {get;set;}
     string MyVar3 {get;set;}

     // Method to be implemented
     bool MyFunc();
}

你继承的类看起来像这样：

public class MyInheritedClass :IMyBaseClass
{
    public string MyVar1 {get;set;}
    public string MyVar2 {get;set;}
    public string MyVar3 {get;set;}

    public MyInheritedClass() 
    {
         this.MyVar1 = "whatever";
         this.MyVar2 = "something";
         this.MyVar3 = "something else";
    }

    public bool MyFunc()
    {
       // do some code here
    }
}

注意我没有必要在属性上编写override，因为如果您的类继承自Interface，那么您可以为每个类实现自己的实现。就像abstract类一样，interface不能用作对象。

c＃类设计用于具有继承的字段

3 个答案: