Skip to main content

How to Resolve Error "CS0236: A field initializer cannot reference the non-static field, method, or property" in C#

The Compiler Error CS0236 is an initialization scope error. The message reads: "A field initializer cannot reference the non-static field, method, or property 'Name'".

In C#, when you declare a field and assign it a value immediately (e.g., int x = 10;), that assignment happens during the object's creation phase, before the constructor runs. At this specific moment, the object instance (this) is considered "under construction." Consequently, you are not allowed to use this to reference other instance fields, properties, or methods to initialize the current field.

This guide explains the lifecycle of object initialization and how to properly set up dependent fields.

Understanding Field Initialization Scope​

When the C# compiler processes a class, it initializes fields in a specific order. However, it strictly forbids a field initializer from accessing this.

  • Static Members: exist independently of any instance. You can use them to initialize fields.
  • Instance Members: require this to be accessed (even if you don't type this., it is implied). Since this is not valid in a field initializer, you cannot reference them.

Scenario 1: Field Depending on Another Field​

This is the most common occurrence. You declare Field A, and immediately try to declare Field B using the value of A.

Example of error:

public class User
{
    public int BaseId = 100;

    // ⛔️ Error CS0236: A field initializer cannot reference the non-static field...
    // To the compiler, this looks like: int CurrentId = this.BaseId + 1;
    // 'this' is unavailable here.
    public int CurrentId = BaseId + 1;
}

Scenario 2: Calling a Method for Initialization​

You might write a helper method to calculate an initial value for a field. Even though the logic seems sound, you cannot call an instance method during field declaration.

Example of error:

public class Configuration
{
    // ⛔️ Error CS0236: 'GetDefaultPath' is an instance method.
    // It cannot be called outside of a constructor or another method.
    public string ConfigPath = GetDefaultPath();

    public string GetDefaultPath()
    {
        return "C:\\App\\config.xml";
    }
}

Solution 1: Move to Constructor (The Standard Fix)​

The constructor is designed specifically for initialization that involves logic or dependencies between fields. Inside the constructor, the object instance exists, so this is valid.

Solution: leave the declaration at the top, but move the assignment inside the constructor.

public class User
{
    public int BaseId = 100;
    public int CurrentId;

    public User()
    {
        // ✅ Correct: 'this' is valid here.
        // We can safely access BaseId to set CurrentId.
        CurrentId = BaseId + 1;
    }
}

Solution 2: Use Properties (Calculated Values)​

If the second field depends entirely on the first field and should always update when the first one changes, you shouldn't use a Field at all. You should use a Property.

Solution: use an Expression-Bodied Property (=>).

public class User
{
    public int BaseId { get; set; } = 100;

    // ✅ Correct: This is now a Property, not a Field.
    // It calculates the value every time it is accessed.
    public int CurrentId => BaseId + 1;
}
note

This approach is often better than the constructor approach if BaseId is expected to change during the object's lifetime. With the constructor fix, CurrentId is set once and never updates. With the property fix, CurrentId is always BaseId + 1.

Solution 3: Make the Source Static​

If the field or method you are referencing does not actually rely on specific object data (e.g., it's a constant or a utility function), mark it as static. Static members are initialized before instance members and do not require this.

Solution:

public class Configuration
{
    // ✅ Correct: Making the method static allows it to be used in a field initializer.
    public string ConfigPath = GetDefaultPath();

    // This method doesn't use any instance data, so 'static' is appropriate.
    public static string GetDefaultPath()
    {
        return "C:\\App\\config.xml";
    }
}

Conclusion​

CS0236 ensures that you don't access an object before it is fully ready.

  1. Constructor: If you need to initialize a variable based on another variable, do it in the constructor.
  2. Property: If the value is a calculation based on other fields, use a Property (=>).
  3. Static: If the dependency is a constant or utility method, make it static.

Table of Contents