Question

我从派生类设置基类的属性如下：

public abstract class Coverter
{
    public Mydata data { get; set; }
    public abstract void Convert();

}
public class Mydata
{
    public int i;
}
public class Coverter1 : Coverter
{
    public Coverter1(Mydata data1)
    {
        data = data1;
    }

    public override void Convert()
    {
        Console.WriteLine(data.i.ToString());

    }
}

private static void Main(string[] args)
{
    Mydata data = new Mydata();
    data.i = 5;
    Coverter c = new Coverter1(data);
    c.Convert();
    Console.ReadLine();
}

这种实施有什么缺陷吗？什么是更好的方法？

我可以用以下方法做同样的事情。

public abstract class Coverter
    {
        public Mydata data { get; set; }
        public abstract void Convert();

    }

    public class Mydata
    {
        public int i;
    }
    public class Coverter1:Coverter
    {
      override public void Convert()
      {
          Console.WriteLine(data.i.ToString());

      }
    }
    static void Main(string[] args)
    {
        Mydata data1 = new Mydata();
        data1.i = 5;
        Coverter c = new Coverter1();
        c.data = data1;
        c.Convert();
        Console.ReadLine();
    }

哪个appraoch更好？

Answer 1

在构造函数中向下传递字段。（注意：通常您应该命名以小写字符开头的字段和以大写字母开头的属性）。这是我修复命名的示例。

public abstract class Converter
{
    private readonly MyData data;
    protected Converter(MyData data)    
    {
       this.data = data;
    }

    public MyData Data { get { return data; } }    
}

public class MyData
{        
    private readonly int value;
    public MyData(int value)
    {
       this.value = value;
    }

    public int MyValue { get { return value; } }
}

public class Converter1 : Converter
{
   public Converter1()
      : base(new MyData(5))
   {
   }
}

我建议仅对属性开始使用只读字段和getter的做法。这样做会使您的类型不可变，这通常有助于您的程序最初正确。从不可变开始，然后在需要的地方引入可变性，并且只在需要时引入。像这样的类型不可变需要通过构造函数传递值。

使用派生类Constructor设置基类属性

1 个答案: