C# Auto-Implemented Properties: Understanding { get; set; }

By the end of this page, you will understand C# properties, the roles of get and set, and why public string Name { get; set; } is called an auto-implemented property. You will also know when to use a property, a field, a read-only property, and validation inside a setter.

Name is a property of the Genre class.

public string Name { get; set; }

It declares a public value named Name whose type is string.

• get lets other code read the value.
• set lets other code assign or change the value.

For example:

var genre = new Genre();
genre.Name = "Science Fiction"; // Uses set

Console.WriteLine(genre.Name);   // Uses get

Because the property contains only get; set; with no custom code, it is an auto-implemented property. The C# compiler creates a hidden storage field behind the scenes and connects the get and set accessors to it.

Properties matter because they provide controlled access to an object's data. Today, a property can simply store a value. Later, you can add validation, formatting, logging, or access restrictions without necessarily changing code that uses .

Think of an object as a cabinet and its data as items inside it.

A field is like leaving an item directly on an open shelf. A property is like using a labeled drawer:

• The get accessor is the rule for taking a look inside the drawer.
• The set accessor is the rule for putting something into the drawer.

An auto-property gives you a standard drawer with ordinary read and write access:

public string Name { get; set; }

Later, you can change the drawer's rules—for example, refuse an empty name—while users of the class still write genre.Name = "Drama".

The general property syntax is:

accessModifier Type PropertyName
{
    get;
    set;
}

An auto-implemented property:

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

Using it:

var genre = new Genre();

genre.Name = "Comedy";
string selectedGenre = genre.Name;

Console.WriteLine(selectedGenre); // Comedy

genre.Name = "Comedy" calls the property's set accessor. Reading genre.Name calls its get accessor.

Equivalent expanded version

The auto-property is conceptually similar to this longer code:

public class Genre
{
    private string _name;

      Name
    {
        
        {
             _name;
        }
        
        {
            _name = ;
        }
    }
}

Consider this program:

var genre = new Genre();
genre.Name = "Horror";

string label = genre.Name;
Console.WriteLine(label);

Execution happens in this order:

1. new Genre() creates a Genre object. Its Name property has its default value, which is null for a normal string reference.
2. genre.Name = "Horror" invokes Name's set accessor. The value "Horror" is stored in the property's hidden backing field.
3. genre.Name on the right side of string label = ... invokes the get accessor.
4. The getter returns "Horror".
5. label receives that value.
6. Console.WriteLine(label) prints Horror.

Properties are used throughout C# applications to describe data and expose object state.

• ASP.NET MVC models: A Genre model can expose Name so MVC can bind form input and display it in a view.
• Entity Framework models: Properties often represent database columns, such as Title, Price, or CreatedAt.
• API request and response DTOs: JSON serializers commonly read and write public properties.
• Configuration objects: Properties hold settings such as ConnectionString or EnableCaching.
• Domain objects: A property can prevent invalid values, such as a negative price or blank product name.

Example model used by a form:

public class CreateGenreRequest
{
    public string Name { get; set; } = string.Empty;
}

When a user submits a Name value, ASP.NET can populate this public writable property during model binding.

In production code, properties commonly express who is allowed to read or modify a value.

Public read and write

Useful for simple model or request data:

public string Name { get; set; } = string.Empty;

Public read, restricted write

Useful when a value should only change inside the class:

public decimal Balance { get; private set; }

public void Deposit(decimal amount)
{
    if (amount <= 0)
    {
        throw new ArgumentOutOfRangeException(nameof(amount));
    }

    Balance += amount;
}

Other code can read Balance, but only BankAccount can set it.

Read-only after construction

Useful for values that identify an object:

public Guid Id { ; ; } = Guid.NewGuid();

Confusing a property with a field

This is a public field, not a property:

public string Name;

This is a property:

public string Name { get; set; }

Properties can later add logic without changing the calling syntax.

Thinking get and set are method calls you write manually

You usually use assignment and reading syntax:

genre.Name = "Drama"; // set
a = genre.Name;        // get

Do not try to call genre.set(...) or genre.get().

Using a property as though it were a method

This is incorrect:

var name = genre.Name();

A property is accessed without parentheses:

 name = genre.Name;

// Read and write
public string Name { get; set; } = string.Empty;

// Read publicly; write only inside this class
public string Name { get; private set; } = string.Empty;

// Read-only property
public string Name { get; }

// Set only when constructing the object
public string Name { get; init; } = string.Empty;

• A property exposes data through accessors.
• get returns the value when code reads the property.
• set receives value when code assigns the property.
• { get; set; } is an auto-implemented property: C# creates hidden storage.
• Read a property with object.Property.
• Write a property with object.Property = newValue.
• Use a backing field and a full property for validation or transformations.
• Initialize non-nullable properties, for example with , when appropriate.

What does { get; set; } mean in C#?

It declares a property that can be read (get) and assigned (set). With no accessor bodies, C# automatically creates hidden storage for its value.

Is Name a variable or a method?

Name is a property. It is accessed similarly to a variable, but it can run code through its getter or setter.

Why use a property instead of public string Name;?

A property provides encapsulation. You can later add validation, restrict writes, or change implementation details while preserving usage such as genre.Name.

Does get; set; create a field?

It causes the compiler to create a hidden backing field for an auto-implemented property. You should normally interact with the property, not that generated field.

Can I make a property read-only?

Yes. Use a getter without a public setter:

public string Name { get; }

You can assign it in a constructor.

What is the value keyword in a setter?

In a custom accessor, is the value being assigned:

• Fields — Direct storage variables in a class; useful for understanding what an auto-property hides.
• Encapsulation — The object-oriented principle behind controlling access through properties.
• Access modifiers — public, private, and related modifiers determine who can use a property or accessor.
• Constructors — Commonly assign values to read-only properties when an object is created.
• Nullable reference types — Help express whether a property such as Name may contain null.
• Object initializers — A concise way to assign writable or init properties during object creation.
• Model binding in ASP.NET MVC — Uses model properties to receive values from HTTP requests.
• Data annotations — Add validation metadata such as [Required] to model properties.