C#：通过构造函数与实例化将数据分配给属性

Question

假设我有一个 Album 类：

public class Album 
{
    public string Name {get; set;}
    public string Artist {get; set;}
    public int Year {get; set;}

    public Album()
    { }

    public Album(string name, string artist, int year)
    {
        this.Name = name;
        this.Artist = artist;
        this.Year = year;
    }
}

当我想将数据分配给Album 类型的对象时，接下来的两种方法有什么区别：

通过构造函数

var albumData = new Album("Albumius", "Artistus", 2013);

或实例化时

var albumData = new Album 
                    {
                         Name = "Albumius",
                         Artist = "Artistus",
                         Year = 2013
                    };

Answer 1

第二种方法是object initializer in C#

对象初始值设定项让您可以将值分配给任何可访问的字段或 创建时对象的属性无需 显式调用构造函数。

第一种方法

var albumData = new Album("Albumius", "Artistus", 2013);

显式调用构造函数，而在第二种方法中，构造函数调用是隐式的。使用对象初始化器，您也可以省略一些属性。喜欢：

 var albumData = new Album
        {
            Name = "Albumius",
        };

对象初始值设定项会转化为：

var albumData; 
var temp = new Album();
temp.Name = "Albumius";
temp.Artist = "Artistus";
temp.Year = 2013;
albumData = temp;

为什么它使用临时对象（在调试模式下）由 Jon Skeet here 回答。

就这两种方法的优势而言，如果您不想初始化所有字段，IMO 对象初始化器会更容易使用。就性能差异而言，我认为不会有任何差异，因为对象初始值设定项会调用无参数构造函数，然后分配属性。即使会有性能差异，也应该可以忽略不计。

Answer 2

这两种方法都调用构造函数，它们只是调用不同的构造函数。这段代码：

var albumData = new Album 
                {
                     Name = "Albumius",
                     Artist = "Artistus",
                     Year = 2013
                };

是这个等效代码的语法简写：

var albumData = new Album();
albumData.Name = "Albumius";
albumData.Artist = "Artistus";
albumData.Year = 2013;

两者在编译后几乎相同（对于几乎所有意图和目的来说足够接近）。因此，如果无参数构造函数不是公开的：

public Album() { }

那么您将根本无法使用对象初始化程序。 所以主要问题不是在初始化对象时使用哪个构造函数，而是对象首先公开的构造函数。 如果对象公开了两个构造函数（如您示例中的构造函数） ，那么可以假设这两种方式对于构造对象同样有效。

有时对象不公开无参数构造函数，因为它们需要某些值来构造。尽管在这种情况下，您仍然可以对其他值使用初始化语法。例如，假设您的对象上有这些构造函数：

private Album() { }
public Album(string name)
{
    this.Name = name;
}

由于无参数构造函数是私有的，你不能使用它。但是你可以使用另一种并且仍然使用初始化语法：

var albumData = new Album("Albumius")
                {
                     Artist = "Artistus",
                     Year = 2013
                };

编译后的结果将与以下内容相同：

var albumData = new Album("Albumius");
albumData.Artist = "Artistus";
albumData.Year = 2013;

Answer 3

对象初始化器很酷，因为它们允许您设置内联类。权衡是你的类不能是不可变的。考虑：

public class Album 
{
    // Note that we make the setter 'private'
    public string Name { get; private set; }
    public string Artist { get; private set; }
    public int Year { get; private set; }

    public Album(string name, string artist, int year)
    {
        this.Name = name;
        this.Artist = artist;
        this.Year = year;
    }
}

如果类是这样定义的，这意味着在类构建后没有一种简单的方法来修改类的内容。不变性有好处。当某些东西是不可变的时，非常更容易确定它是正确的。毕竟，如果它在构建后无法修改，那么它就永远不会“错误”（一旦你确定它的结构是正确的）。当您创建匿名类时，例如：

new { 
    Name = "Some Name",
    Artist = "Some Artist",
    Year = 1994
};

编译器会自动创建一个不可变类（即匿名类在构造后不能被修改），因为不变性就是那么有用。出于这个原因，大多数 C++/Java 风格指南经常鼓励创建成员 const(C++) 或 final (Java)。当活动部件较少时，更大的应用程序更容易验证。

话虽如此，在某些情况下，您希望能够快速修改类的结构。假设我有一个要设置的工具：

public void Configure(ConfigurationSetup setup);

我有一个有许多成员的类，例如：

class ConfigurationSetup {
    public String Name { get; set; }
    public String Location { get; set; }
    public Int32 Size { get; set; }
    public DateTime Time { get; set; }

    // ... and some other configuration stuff... 
}

当我想配置一些属性的组合，但不一定要同时配置所有这些时，使用对象初始化器语法很有用。例如，如果我只想配置Name 和Location，我可以这样做：

ConfigurationSetup setup = new ConfigurationSetup {
    Name = "Some Name",
    Location = "San Jose"
};

这允许我设置一些组合，而不必为每个可能的排列定义一个新的构造函数。

总的来说，我认为从长远来看，使您的类不可变会为您节省大量的开发时间，但是使用对象初始化器语法可以更容易地设置某些配置排列。