C# 14’s New ‘field’ Keyword: Goodbye Property Backing Fields!

The upcoming C# 14 (part of .NET 10) brings an exciting new feature that will make property implementations cleaner and more maintainable. The new field keyword eliminates the need for explicit backing fields, allowing you to add logic directly within auto-implemented properties. Let’s explore this feature and see how LINQPad makes it easy to experiment with the latest C# previews.

Why This Matters

For years, C# developers have had to choose between two approaches when implementing properties:

Auto-implemented properties (clean but limited)
Full property implementations with backing fields (flexible but verbose)

The new field keyword bridges this gap, giving us the best of both worlds: the cleanliness of auto-implemented properties with the flexibility to add custom logic.

Getting Started with C# 14 in LINQPad

One of the best things about LINQPad is how easy it makes testing new language features. To try out C# 14:

Install the .NET 10 preview
In LINQPad, set your script to use .NET 10
Start coding!

Download LINQPad Today

Get started with the most powerful .NET Rapid Progress Tool (RPT) available.

Get LINQPad Premium

Powerful .NET acceleration. Code at the speed of thought.

The New `field` Keyword in Action

Let’s look at a practical example that demonstrates the power of the new field keyword:

public string Message10
{
    get {
        if (string.IsNullOrWhiteSpace(field)) {
            return "https://www.learninglinqpad.com";
        } else {
            return field;
        }
    }

    set {
        if (string.IsNullOrWhiteSpace(value)){
            throw new ArgumentNullException(nameof(value));
        } else {
            field = value;
        }
    }
}

Compare this with the traditional approach we’ve been using for years:

private string _message;
public string Message
{
    get => _message;
    set
    {
        _message = value ?? throw new ArgumentNullException(nameof(value));
    }
}

Key Benefits of the `field` Keyword

Cleaner Code: No more need to declare and manage backing fields
Better Encapsulation: The backing field is truly private to the property
Reduced Boilerplate: Less code to write and maintain
Improved Readability: Property logic is self-contained

Testing in LINQPad

Here’s a complete example you can run in LINQPad to see the new feature in action:

void Main()
{
	Message10.Dump("getter");

	try
	{
		Message10 = null;
	}
	catch (Exception e) { e.Dump("exception10"); }

	try
	{
		Message = null;
	}
	catch (Exception e) { e.Dump("exception"); }
}

// C# 14 / .NET 10 and newer, the `field` gets the compiler to use an auto generated backing field intermixed with the additional logic
public string Message10
{
	// this is valid
	// get;
	get {
		if (string.IsNullOrWhiteSpace(field)) {
			return "https://www.learninglinqpad.com";
		} else {
			return field;
		}
	}

	// this is valid!
	// set => field = (value ?? throw new ArgumentNullException(nameof(value)));

	// this is valid too!
	set {
		if (string.IsNullOrWhiteSpace(value)){
			throw new ArgumentNullException(nameof(value));
		} else {
			field = value;
		}
	}
}

// C# 13 / .NET 9 and below, a backing field is required to do any additional work inside the getter/setter
private string _message;
public string Message
{
	get => _message;
	set
	{
		_message = value ?? throw new ArgumentNullException(nameof(value));
	}
}

LINQPad showing the new `field` keyword using C# 14

When to Use the `field` Keyword

The field keyword is perfect for scenarios where you need to:

Add validation logic to property setters
Implement computed or derived values in getters
Add logging or debugging code
Implement lazy initialization
Add business logic to property access

Best Practices

Keep It Simple: Don’t overcomplicate property logic
Maintain Consistency: Use the same pattern across your codebase
Document Complex Logic: Add comments for non-obvious implementations
Consider Performance: Keep property logic lightweight

Looking Back and Forward

It’s been a long journey from the early days of C# to this new feature. While we’ve had to wait 15 years for this improvement, it’s a welcome addition that will make our code cleaner and more maintainable.

Conclusion

The new field keyword in C# 14 represents a significant improvement in how we can implement properties. By eliminating the need for explicit backing fields, it makes our code cleaner and more maintainable while still providing all the flexibility we need.

LINQPad makes it easy to experiment with this new feature, allowing you to quickly test different property implementations and see how they work in practice.

Want to learn more about LINQPad and how it can supercharge your development workflow? Check out my comprehensive LINQPad course where I cover everything from basic queries to advanced scenarios like the ones shown here.

C# 14's New 'field' Keyword: Goodbye Property Backing Fields!