Question

I have a confusion about understanding Property and Variables

public class ABC()
{
    public int A;
    public int B { get; set; }
}

What is the exact difference between in A and B?

Answer 1

As many have pointed out, A is a field, B is a property.

The real question is, why should you care, and what to use?

I refer to a blog post of Jonathan Aneja:

(Its in VB, but it applies to C# as well ;))

So why use properties over fields, 5 reasons:

1. Fields can’t be used in Interfaces

You can’t enforce the existence of a
field in an object’s public contract
through an interface. For properties
though it works fine.

2. Validation

While your application currently may
not require any validation logic to
set a particular value, changing
business requirements may require
inserting this logic later. At that
point changing a field to a property
is a breaking change for consumers of
your API. (For example if someone was
inspecting your class via reflection).

3. Binary Serialization

Changing a field to a property is a
breaking change if you’re using binary
serialization. Incidentally, this is
one of the reasons VB10’s
auto-implemented properties have a
“bindable” backing field (i.e. you can
express the name of the backing field
in code) – that way, if you change an
auto-implemented property to an
expanded property, you can still
maintain serialization compatibility
by keeping the backing field name the
same (in C# you’re forced to change it
because it generates backing fields
with unbindable names).

4. A lot of the .NET databinding infrastructure binds to properties but not fields

I’ve heard arguments on both sides as
to whether or not that’s a good thing,
but the reality is that’s the way it
works right now. (Note from me: WPF bindings work on properties)

5. Exposing a public field is an FxCop violation

For many of the reasons listed above
🙂

There might be more reasons.

I would also like to point to a blog post of Jeff Atwood and conclude with a quote from it:

The really important thing to take away here is to avoid writing code that doesn’t matter. And property wrappers around public variables are the very essence of meaningless code.