我创建了一个自动化属性:

public int Foo { get; } 

这只是 setter/getter 。 但是当我构建构造函数时，我可以更改值:

public MyClass(string name)
{
    Foo = 5;
}

为什么这是可能的，即使这是 get-only？

最佳答案

这是一个新的 C# 6 功能，“Getter-only auto-properties”，也称为“Read-Only Properties 的 Auto-Property Initializers”，如本 MSDN magazine article 'C# : The New and Improved C# 6.0' by Mark Michaelis 中所述。在C# 6.0 draft Language Specification .

只读字段的 setter 只能在构造函数中访问，在所有其他情况下，该字段仍然是只读的并且行为与以前一样。

这是一种方便的语法，可以减少您需要键入的代码量，并且无需显式声明私有(private)模块级变量来保存值。

自从在 C#3 中引入自动实现的属性以来，此功能被视为重要，可变属性(具有 getter 和 setter 的属性)比不可变属性(仅具有 getter 的属性)编写起来更快，这意味着人们很想使用可变属性来避免为只读属性通常需要的支持字段键入代码。 relevant section of the Microsoft C# Programming Guide 中有更多关于自动实现属性的讨论。 .

This blog post, '#1,207 – C# 6.0 – Auto-Property Initializers for Read-Only Properties' by Sean Sexton有很好的解释和例子如下:

Prior to C# 6.0, if you wanted a read-only (immutable) property, you’d typically use a read-only backing field that is initialized in the constructor, as shown below.

public class Dog 
{
    public string Name { get; set; }

    // DogCreationTime is immutable
    private readonly DateTime creTime;
    public DateTime DogCreationTime 
    {
        get { return creTime; }
    }

    public Dog(string name)
    {
        Name = name;
        creTime = DateTime.Now;
    }
}

In C# 6.0, you can use auto-implemented properties to implement a read-only property. You do this by using an auto-property initializer. The result is much cleaner than the above example, where we had to explicitly declare a backing field.

public class Dog
{
    public string Name { get; set; }

    // DogCreationTime is immutable
    public DateTime DogCreationTime { get; } = DateTime.Now;

    public Dog(string name)
    {
        Name = name;
    }
}

更多详细信息也可以在 the dotnet Roslyn repo on GitHub 中找到:

Auto-properties can now be declared without a setter.

The backing field of a getter-only auto-property is implicitly declared as readonly (though this matters only for reflection purposes). It can be initialized through an initializer on the property as in the example above. Also, a getter-only property can be assigned to in the declaring type’s constructor body, which causes the value to be assigned directly to the underlying field:

This is about expressing types more concisely, but note that it also removes an important difference in the language between mutable and immutable types: auto-properties were a shorthand available only if you were willing to make your class mutable, and so the temptation to default to that was great. Now, with getter-only auto-properties, the playing field has been leveled between mutable and immutable.

并且在 C# 6.0 draft Language Specification (注意:就 Microsoft 而言，语言规范是最终版本，但它是 yet to be approved as a EMCA/ISO standard ，因此是“草案”):

Automatically implemented properties

An automatically implemented property (or auto-property for short), is a non-abstract non-extern property with semicolon-only accessor bodies. Auto-properties must have a get accessor and can optionally have a set accessor.

When a property is specified as an automatically implemented property, a hidden backing field is automatically available for the property, and the accessors are implemented to read from and write to that backing field. If the auto-property has no set accessor, the backing field is considered readonly (Readonly fields). Just like a readonly field, a getter-only auto-property can also be assigned to in the body of a constructor of the enclosing class. Such an assignment assigns directly to the readonly backing field of the property.

An auto-property may optionally have a property_initializer, which is applied directly to the backing field as a variable_initializer (Variable initializers).

关于c# - 只有getter的自动化属性，可以设置，为什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34743533/