Question

我是一位非常新的程序员并且理解我们希望最大限度地减少代码冗余，因此在我们更新时，我们可以尽可能少地进行更改并最大限度地减少错误。

所以我有一个Student类，我想要重载构造函数所以如果我重新链接它就像这样。

 public class Student
{
    string name;
    int Id;

    public Student()
    {
    }
    public Student(string name)
    {
        this.name = name;
    }
    public Student(string name, int Id) :this(name)
    {
        this.Id = Id;

但这显然很糟糕，因为我们想要一个构造函数中的所有代码是出于什么原因？易于阅读？

    public Student() : this(null, 0)
    { }
    public Student(string name) : this(name, 0)
    { }
    public Student(string name, int Id) 
    {
        this.name = name;
        this.Id = Id;
    }

如果我这样做正向链接那么如果我们添加一个像字符串major这样的新字段会发生什么？如果我转发链接，那么我使用添加的字段创建一个新的重载构造函数。但现在我必须更改所有其他构造函数以调用新构造函数。如果我进行向后链接，我只需创建一个新的构造函数并调用前一个重载的构造函数。

    public Student(string name, int Id, string major):this(name, Id)
    {
        this.major=major;
    }

这似乎更符合OOP，但我的教科书中的所有示例都显示了前向链接，并且没有说明为什么我不应该使用反向链接。

如果我使用命名/可选参数，那就更容易了。

    public Student(string name = null, int Id = 0, string major = null)
    {
        this.name = name;
        this.Id = Id;
        this.major = major;
    }

如果我需要另一个字段，我只需要编辑唯一的构造函数。这似乎遵循OOP原则最好还是我错了？它至少消除了代码重复。我的任务是按照OOP＆＃34;的原则实施学生课程。我知道所有这些都是有效的，但是编码构造函数的最佳/可接受的方式之一是什么？缺少命名/可选参数的缺点吗？作为初学者，有很多方法可以解决这个问题，这让人非常困惑。

Answer 1

没有最佳方式，因为它们不同，每种方式都有优点和缺点。

自C＃1.0起，独立构造函数和链式构造函数可用，在大多数情况下我们使用链式构造函数，但有时我们必须使用前者，如果两个构造函数有完全不同的东西要处理。

class Student
{
    public Student()
    {
        DoSomething();
    }

    public Student(string name)
    {
        this.Name = name;
        DoAnotherThing();
    }
}

与可选参数构造函数相比，上面两个更长，但说实话，它们更安全。考虑以下情况：

public class Student
{
    public Student(string firstName = null, string lastName = null)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
    }

    public string FirstName { get; set; }
    public string LastName { get; set; }
}

//it's working fine
//var danny = new Student("danny", "chen");

//as the business grows a lot of students need a middle name
public Student(string firstName = null, string middleName = null, string lastName = null)
{
    this.FirstName = firstName;
    this.MiddleName = middleName;
    this.LastName = lastName;
}

//for a better sequence the programmer adds middleName between the existing two, bang!

他们之间的另一个区别是使用反射。可选参数不会为您生成更多构造函数，如果使用反射调用构造函数，则不会应用默认值。

Answer 2

我知道所有这些都是有效的，但是编码构造函数的最佳/可接受的方式之一是什么？

据我所知，你有很多选择。您的同事是与之达成共识的最佳人选。 C＃正在成为一种非常丰富的语言，这意味着将有许多不同的方法来实现同样的目标。

我缺少指定/可选参数的缺点吗？

据我所知。我个人认为这是最好的解决方案，但其他人可能会有所不同。

作为一名初学者，有很多方法可以解决这个问题。

欢迎编程。我们有数百万的程序员，而且我们都忙于为世界增加复杂性！

Answer 3

我建议更深入地研究这个假设：

“但这显然很糟糕，因为我们希望一个构造函数中的所有代码都是出于什么原因”

有Fluent Interface Pattern将这些事情分开，我也不能强烈地认为这直接转化为构造函数。

customer
    .NameOfCustomer("Shiv")
    .Bornon("12/3/1075")
    .StaysAt("Mumbai");

说明性实施：

public class Customer
{
    public string FullName { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string Address { get; set; }

    public Customer NameOfCustomer(string name)
    {
        this.FullName = name;
        return this;
    }

    public Customer BornOn(DateTime dateOfBirth)
    {
        this.DateOfBirth = dateOfBirth;
        return this;
    }

    public Customer StaysAt(string address)
    {
        this.Address = address;
        return this;
    }
}

Example source

Answer 4

这是部分答案。您的“向后链接”，其中一个构造函数设置了一些参数，然后为其余的构造函数调用了另一个构造函数，对于正常的 function 是非常合理/合理的：一个函数完成了部分工作，然后调用了另一个进行其他工作，等等。

但是对于公共构造函数，其中任何一个都可以由客户端代码调用，期望获得一个完全构造的对象，并对其进行完全初始化。示例中的某些构造函数使成员未初始化（除非您想要的是该类型的默认值）。

或者，您可以使用 private 构造函数。

构造函数链接或使用命名/可选参数

4 个答案: