Auto-Implemented Properties c#

1. could someone explain me what's the idea behind using Auto-Implemented Properties c#?

   public class Customer
   {
       public int ID { get; set; }
       public string Name { get; set; }
   }
   

   I get the motivation to use properties for private field, so we can determine how one can access a private field. But here - it's just like defining the field to be public from the first place. no?

2. Is there a difference between defining a field to be "开发者_运维技巧public const" or define it to have a get-only property ?

A public automatic property is not the same as a public field, they are not binary compatible. If you implement a public field and later on want to add some logic, you will have to change it into a property and thereby introduce a breaking change (because of the binary incompatibility). This is the reason why many conventions state that you should never expose public fields but rather use properties.

So, automatic properties are just a convenient starting point for any simple non-private class value member, allowing one to add logic later on while keeping binary compatibility.

Properties can be databound, whereas fields can not.

Automatically implemented properties are essentially syntactic sugar. Once compiled, the backing store exists. It just isn't available from the source code.

As others have stated, properties and fields are not equivalent. Fields and properties aren't compatible so changing between them is a breaking change. In addition, you cannot use data binding with fields.

Final point. Though in your case there's little functional difference between the example and a public field, you can change the visibility of one of the accessors. So, to create a read-only property using an automatic property, you may do something like:

public int ID { get; private set; }

In this case, the get accessor is public, as per the entire signature, but the set accessor is private.

I will let MSDN do the talking here....

"In C# 3.0 and later, auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors. They also enable client code to create objects. When you declare a property as shown in the following example (see MSDN article for example), the compiler creates a private, anonymous backing field that can only be accessed through the property's get and set accessors"

Probably the most advantageous difference is you can do pre/post validation, raise PropertyChanged events etc

Is there a difference between defining a field to be "public const" or define it to have a get-only property?

Yes, a get-only field must have a private field declaration. This field can be changed by the class internally, marking a field as const means it cannot be modified.

2: a public const has to be defined at compiletime, you cannot use reference objects for that. Only classes that inherit from System.ValueType (string, int, double, ...)

A const is also static whereas a property with only a getter is not (every class has it's own instance.)

Add logic to getter function. Can access values of another property

 public string Status
    {
        get { return DeactivateDate != null ? "InActive" : "Active"; }
        private set { }
    }