Skip to main content

How to Resolve Error "CS0843: Auto-implemented property must be fully assigned" in C#

The Compiler Error CS0843 is a definite assignment error specific to Structs. The message reads: "Auto-implemented property 'Name' must be fully assigned before control is returned to the caller."

In C#, struct constructors have a strict rule: Every field and property in the struct must be initialized (assigned a value) before the constructor finishes.

Unlike classes, where fields default to zero/null automatically, older versions of C# required structs to explicitly set every member. If you have an Auto-Implemented Property ({ get; set; }) inside a struct constructor, and you forget to assign a value to it (or call the default constructor this()), the compiler cannot access the hidden backing field to set it to zero, resulting in CS0843.

Understanding Struct Initialization Rules​

When you define a struct, it is a Value Type. To ensure high performance and predictability, C# constructors for structs do not run standard initialization logic unless explicitly told to.

  • Classes: Unassigned fields are automatically set to default (0, null, false).
  • Structs (Pre-C# 11): The constructor is responsible for initializing everything. An Auto-Property generates a hidden backing field. If you don't assign to the property, that hidden field remains uninitialized, which is illegal.

Scenario 1: Missing Assignment in Constructor​

This is the standard trigger. You have a struct with two properties, but the constructor only sets one of them.

Example of error:

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }

    // ⛔️ Error CS0843: Auto-implemented property 'Point.Y' must be fully assigned.
    // We set X, but we forgot Y.
    public Point(int x)
    {
        X = x;
    }
}

Solution 1: Assign the Property​

The most direct fix is to ensure that every auto-property is assigned a value inside the constructor body.

Solution:

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public Point(int x)
    {
        X = x;
        
        // ✅ Correct: All properties are now assigned.
        Y = 0; 
    }
}

Solution 2: Call the Default Constructor (: this())​

If you have many properties and only want to set a few (leaving the rest as defaults), you can chain the constructor to this().

The expression : this() invokes the built-in default constructor first, which wipes the entire struct memory to zero (setting all ints to 0, bools to false, etc.). This satisfies the "fully assigned" requirement immediately, allowing your constructor body to set only specific properties.

Solution:

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }

    // ✅ Correct: ': this()' initializes everything to default (0) first.
    public Point(int x) : this()
    {
        // Now we only need to set what we care about.
        X = x;
        // Y is already 0 thanks to this()
    }
}

Solution 3: Update Language Version (C# 11+)​

If you are using .NET 7 (C# 11) or newer, the C# language rules for structs have changed. The compiler now automatically initializes any struct fields or auto-properties that you forget to set in the constructor to their default values.

If you are seeing this error, you might be targeting an older framework or language version.

Check your .csproj​

If you are on an older framework but using a modern compiler (VS 2022+), you might try explicitly setting the language version.

<PropertyGroup>
   <!-- C# 11 automatically fixes CS0843 by auto-defaulting properties -->
   <LangVersion>11</LangVersion>
</PropertyGroup>
warning

This solution only works if your environment supports C# 11 features. If you are stuck on .NET Framework 4.8 or older build servers, use Solution 2 (: this()).

Conclusion​

CS0843 ensures that structs don't contain garbage data.

  1. Check the Constructor: Did you forget to set a property?
  2. Use : this(): This is the cleanest fix for older C# versions. It zeroes out the struct before your logic runs.
  3. Upgrade: If possible, move to C# 11 (.NET 7+), where this behavior is handled automatically.

Table of Contents