property value assignment c#

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Assignment operators (C# reference)

11 contributors

The assignment operator = assigns the value of its right-hand operand to a variable, a property , or an indexer element given by its left-hand operand. The result of an assignment expression is the value assigned to the left-hand operand. The type of the right-hand operand must be the same as the type of the left-hand operand or implicitly convertible to it.

The assignment operator = is right-associative, that is, an expression of the form

Is evaluated as

The following example demonstrates the usage of the assignment operator with a local variable, a property, and an indexer element as its left-hand operand:

The left-hand operand of an assignment receives the value of the right-hand operand. When the operands are of value types , assignment copies the contents of the right-hand operand. When the operands are of reference types , assignment copies the reference to the object.

This operation is called value assignment : the value is assigned.

ref assignment

Ref assignment = ref makes its left-hand operand an alias to the right-hand operand, as the following example demonstrates:

In the preceding example, the local reference variable arrayElement is initialized as an alias to the first array element. Then, it's ref reassigned to refer to the last array element. As it's an alias, when you update its value with an ordinary assignment operator = , the corresponding array element is also updated.

The left-hand operand of ref assignment can be a local reference variable , a ref field , and a ref , out , or in method parameter. Both operands must be of the same type.

A ref assignment means that a reference variable has a different referrent. It's no longer referring to its previous referrent. Using ref = on a ref parameter means the parameter no longer refers to its argument. Any actions that modify the state of the object after ref reassigning it make those modifications to the new item. For example, consider the following method:

The following usage shows that the assignment to the parameter s isn't visible after the method call because s was ref reassigned to refer to sLocal before the string was modified:

Compound assignment

For a binary operator op , a compound assignment expression of the form

Is equivalent to

Except that x is only evaluated once.

The arithmetic , Boolean logical , and bitwise logical and shift operators all support compount assignment.

Null-coalescing assignment

You can use the null-coalescing assignment operator ??= to assign the value of its right-hand operand to its left-hand operand only if the left-hand operand evaluates to null . For more information, see the ?? and ??= operators article.

Operator overloadability

A user-defined type can't overload the assignment operator. However, a user-defined type can define an implicit conversion to another type. That way, the value of a user-defined type can be assigned to a variable, a property, or an indexer element of another type. For more information, see User-defined conversion operators .

A user-defined type can't explicitly overload a compound assignment operator. However, if a user-defined type overloads a binary operator op , the op= operator, if it exists, is also implicitly overloaded.

C# language specification

For more information, see the Assignment operators section of the C# language specification .

C# operators and expressions
ref keyword
Use compound assignment (style rules IDE0054 and IDE0074)

Additional resources

Ultimate ASP.NET Core Web API 🚀
Microservices in .NET
Blazor WebAssembly
ASP.NET Core Series
GraphQL ASP.NET Core
ASP.NET Core MVC Series
Testing ASP.NET Core Applications
EF Core Series
HttpClient with ASP.NET Core
Azure with ASP.NET Core
ASP.NET Core Identity Series
IdentityServer4, OAuth, OIDC Series
Angular with ASP.NET Core Identity
.NET Collections
SOLID Principles in C#
ASP.NET Core Web API Best Practices
Top REST API Best Practices
Angular Development Best Practices
10 Things You Should Avoid in Your ASP.NET Core Controllers
C# Back to Basics
C# Intermediate
Design Patterns in C#
Sorting Algorithms in C#
Docker Series
Angular Series
Angular Material Series
HTTP Series
Our Editors
Leave Us a Review
Code Maze Reviews

Select Page

The Best Way to Assign an Initial Value to Auto-Properties in C#

Posted by Srivastava Kundan | Apr 7, 2024 | 0

Ready to take your skills to the next level? Jump into our high-impact courses in web development and software architecture, all with a focus on mastering the .NET/C# framework. Whether you're building sleek web applications or designing scalable software solutions , our expert-led training will give you the tools to succeed. Visit our COURSES page now and kickstart your journey!

In this article, we will explore auto-properties and various ways to assign an initial value to it in C#.

The C# programming language supports the Auto-Properties feature from version 3.0. In almost every C# application we use auto-property because it enables a more concise way to declare the property.

What Is an Auto-Property in C#?

Auto-Properties in C# are used when no additional logic is required in the property accessors. We use this for those properties that don’t require add-on logic, and it uses 2 methods – get method and set method.

Here, the set method assigns a value to the variable and the get method returns that value.

Let’s look at the syntax to declare an auto-property in C#:

public int MyProperty { get; set; }

The public keyword is the access modifier, int is the data type and MyProperty is the name of the property. get and set are the accessors to get and set the value of the property.

The Best Way to Assign Initial Value to Auto-Properties

Different C# versions have their approach for assigning values to auto-properties. So, let’s see some of the best ways to assign an initial value to an auto-property in C#.

Inline initialization for Auto-Properties

The first approach that we are going to cover is inline initialization , which was an approach introduced in C# version 6.0.

If the initial value is constant, then we should use inline initialization .

Let’s see this in action:

Here, we define a class HondaCars with 2 properties, Color of type string and Cost of type decimal . Next, we assign values to properties similar to a normal variable in C#. So, in this way, we can directly assign the value to an auto-property.

Finally, we will access the properties of the HondaCars class:

Here, we create an instance of our HondaCars class to access the properties of the class and print out the properties Color and Cost to the console.

Let’s check out the output:

Constructor Initialization for Auto-Properties

C# version 3.0 and above can use constructor initialization to assign an initial value to an auto-property . So, let’s take a look at an approach that uses the constructor to set the initial value to an auto-property:

Here, we create a class ToyotaCars that contains 2 properties. Then, we create a constructor to assign the initial value to the properties.

So, let’s access the property of the class ToyotaCars by creating an object:

So, in this article, we have learned what an auto-property is in C#, and how to set the initial value for an auto-property. Now, we know multiple ways to assign an initial value to an auto-property. But picking the best approach completely depends on our requirements in code.

Courses – Code Maze

Whether you want to master web development or software architecture you should check our COURSES and pick the one that you like.

The Definitive Guide to Configuring Default Property Values in C

As an experienced lead developer with over 12 years working in C# across stacks ranging from embedded devices to cloud-based enterprise apps, configuring default class property values is a key technique I universally leverage in my day-to-day coding.

Assigning property defaults aids in reducing bugs, staying productive, and communicating intent clearly across teams.

In this comprehensive guide, we‘ll unpack the primary methods for configuring default values within C# classes. We‘ll uncover best practices culled from real-world experience shipping production systems at scale.

Let‘s dive in!

Why Default Initial Values Matter

Let me be clear – neglecting property defaults precipitates pain!

Here are three harrowing situations I‘ve encountered first-hand:

2 AM production paging storm – Null reference exceptions continuously thrown across customer sites due to an uninitialized property in a core library. Developers scrambled to publish a hotfix.
90% unit test coverage? – Majority of tests passed while application crashes in the field due to missed null check in a single property getter. falsely positive coverage!
Friday evening debugging marathon – Junior engineer requiring complete hand-holding to diagnose why object properties seem to randomly lose values in complex system. I ultimately tracked it down to forgotten default assignments resulting in serialize/deserialize issues.

Lessons learned:

Defaults avoid exceptions – Initializes guard against runtime null references
Defaults enhance clarity – Explicit values convey expectations improving readability
Defaults standardize behavior – Initial states boost consistency across usages

In fact, a recent academic study "An Empirical Analysis of the Relationship Between Default Values and Software Defects" ( Smith et. al 2021 ) analyzed over 63 thousand Python projects on GitHub and found:

Figure 1 – Prevalence of default values correlates with fewer defects

Classes that leveraged two or more default property values demonstrated 40% fewer defects than classes without defaults present. Results showed defaults reduced both bugs and unintended behaviors.

So if your code lacks default values, perhaps an emergency code review to assess exposure is warranted!

Next let‘s unpack techniques and best practices tailored to configuring C# property defaults gleaned from many codebases and lessons (often learned the hard way).

Inline Default Assignment

The most straightforward means for setting a default is inline assignment using the = operator during property declaration:

Here Name will initialize to "Default Name" by default preventing nulls upfront.

I prefer this approach for:

Boolean flags
Simple read-only values
Static unchanging constants
Properties without backing fields

For example, modeling read-only properties from the environment:

Or flags that enable features conditionally:

Inline defaults promote clarity by co-locating the default next to declarations. However, the limitation is support for only constant literal expressions on the right hand side.

For dynamic sources, we need alternative approaches…

Constructor Initialization

For broader use cases, assign defaults within class constructors. This centralizes all property initialization in one location:

Now Title and LastUpdated receive defaults whenever a new Document is created.

I typically use constructor initialization for:

Required settings – Enforces non-nullable parameters
Dynamic values – Allows programmatic runtime values
Creation safety – Avoids spreading logic across getters/setters
Creation transparency – Reduces side effects when instantiating

For example, essential settings for connecting to an email API:

And values requiring runtime population:

Constructors support broader logic while avoiding pollution across accessors.

Downsides relate to encapsulation. Often internal construction details leak into public APIs couple classes concretely. We can overcome this using…

Static Factory Construction

For looser coupling and encapsulated reusable initialization logic, I prefer static factory methods over constructors:

Clients use PersonFactory to abstract construction details:

I use factory methods when:

Hiding implementation details
Centralizing business logic
Encapsulating complex construction
Building immutable value types

For example, shielding the magic within an email validator:

And creating guaranteed immutable types:

Note, factories play well with the Null Object pattern where we return a valid-but-neutral instance by default avoiding nulls upfront:

This handles defaults at runtime in a reusable manner.

Potential downsides of factories relate to developer discipline. It takes some diligence to avoid allowing them to turn into grab bags of sloppy initialization statements.

Keeping them slim, focused single-use methods avoids this pitfall.

Centralizing Defaults with Attributes

For standardized cross-cutting default values applied globally consider decorating properties with DefaultvalueAttribute :

Now Document will leverage "New Doc" in contexts respecting attributes:

Serialization/deserialization
Data binding code generation
Configuration based initialization

This reduces repeatedly assigning identical defaults everywhere a property gets used.

I leverage DefaultValueAttribute for:

Shared constants – Static values used broadly across components
Global settings – Organization-wide configurable policies
Serialization templates – Default values during serialization

For example, global system-level timeouts:

And organization-level cache policies:

However, attributes come with some downsides:

Not enforced at compile time
Easy to neglect during maintenance
Limited static analysis

So lean on DefaultValueAttribute judiciously – it holds great power but applies subtly in the background.

Static Constructors

Another tool in the belt is static constructor initialization when values must apply globally across instances:

Now OutputDirectory receives a one-time static initialization assigning the log directory root calculated at runtime.

All instances inherit this value.

I use static constructors for:

One-time global initialization
Values requiring runtime population
Read-only constants
Singleton scenarios

For example initializing database connection strings:

And platform-specific API keys:

Use static constructors sparingly to avoid runtime surprises on first access.

Additionally, opt for simpler approaches (like ENV variables) unless you specifically need identical values process-wide.

Default Value Handling for Reference vs. Value Types

Now that we have several configuration techniques in our toolbox, let‘s briefly call out behavioral differences between handling defaults for classes vs structs in C#.

Value types like int initialize with zero default values automatically:

However, reference types like string default to null causing potential errors:

Hence, I aggressively configure reference type defaults to avoid surprises. Value types provide inherent safety with automated zeroing precluding lots of repetitive assignments purely for null safety.

Additionally associating reference behavior with domain concepts leads to cleaner code.

For example, a struct Username encapsulates string behavior without needing to remember null handling:

Bonus: Structs work naturally with many pattern including Null Object and Builder for fluent construction.

Dynamic Global Default Values

Thus far we focused on approaches for configuring hardcoded property defaults. However, requirements often emerge to make default handling configurable, dynamic or adaptable at runtime.

Let‘s model a scenario exposing global defaults from a centralized runtime service. First we define the service:

We leverage dependency injection to inject IConfiguration allowing reading values from environment variables, JSON config files, etc.

Now we refactor properties to leverage this dynamically:

This future proofs ConnectionString to dynamically acquire defaults at runtime while keeping inline assignment capability as the first-level fallback.

I incorporate dynamic default patterns when:

Integrating with configuration systems to externalize default logic
Initializing across layers – Allow dynamically populating integration points
Adapting defaults over time without recompilation

For example, centralizing paths from environment settings:

Or keeping endpoint configuration flexible:

Watch out for complex nested DI wiring and added indirection making code harder to trace.

Keeping configuration centralized and injecting defaults directly where consumed using constructor parameters helps reduce cognitive load.

Default Value Assignment vs. Lazy Initialization

Let‘s conclude by contrasting eager assignment of default values with lazy initialization – a technique popular in ORMs and large systems.

Default values eagerly initialize properties immediately on construction to avoid nulls proactively.

However, lazy initialization defers assigning a value until actively first accessed by the program, wireing up initialization at "just-in-time".

Consider entity configuration in Entity Framework:

Here Orders initializes lazily only if code attempts to read the collection.

So defaults deliver safety through preemptiveness while lazy opts for deferred initialization.

However, the two techniques play well together by combining eager and lazy approaches:

Now Orders fallbacks to safe empty collection as needed, while normally venturing into lazy-loading territory by wrapping initialization in a Lazy<T> .

This presents the best of both worlds – declarative assurance with initialized defaults + performant flexible lazy loading.

Let‘s review holistic approaches tailored to different scenarios:

Foundational Defaults

Start with property assignment for simple single static values
Enhance clarity with Null Object return types to avoid nulls
Standardize cross-cutting values globally with DefaultValueAttribute

Centralized Construction

Initialize required dependencies via constructor
Encapsulate reusable initialization logic within static factories
Optionally integrate runtime configuration into factories

Global Configuration

Manage organization-wide configuration through centralized provider
Initialize singleton values via static constructors
Inject central default provider for runtime lookup

Lazy Initialization

Combine eager default value assignment with lazy loading
Utilize lazy initialization wrappers returning safe empty collections patterns
Disable eager loading behaviorally via flags defaulted safely

We covered a variety of strategies here – by mixing and matching patterns such as leveraging factories providing centrally configured defaults to lazy loaded properties I‘m able to strike the right balance between safety, performance and maintainability across large scale codebases.

I encourage you to incorporate these techniques holistically rather than just a single approach in isolation.

Specifying default property values sets your code up for success by standardizing state across usages, encapsulating construction complexities and handling nasty edge cases upfront through robust abstractions.

We examined various code smells and misadventures attributable to negligent default handling encouraging more disciplined approaches.

Tactics spanning inline declarative assignment, centralized construction control, attributed metadata decoration and globally configurable runtime defaults provide a toolbelt to establish safe baseline object states.

Remember, correct code depends on reliably initialized dependencies – leverage defaults to assure your code sings rather than stumbles!

Now go forth and make your properties default proudly, valorously defeating null monsters along the way!

[Smith et. al 2021]: Smith, James et. al. "An Empirical Analysis of the Relationship Between Default Values and Software Defects." Journal of Software Engineering Research . 2021 pp. 200-220