'private static readonly' fields and static/nonstatic constructors

Question

I have three objects :

private static readonly Apple a, c;
private readonly Orange b;

This code is called from my constructor :

public SomeClass()
{
    a = new Apple();
    b = new Orange(a.getDna());
    c = new Apple(b.getDna());
}

It gives me the error Readonly field cannot be used as an assignment target. If I remove either the static or readonly modifiers, it compiles perfectly. (Is there a wrong warning here?)

On checking other answers here on SO, I found that I should use a static constructor like :

static SomeClass()
{
    a = new Apple();
    c = new Apple(b.getDna());
}

public SomeClass()
{
    b = new Orange(a.getDna());
}

But this would cause the static constructor to be called first and cause an error since b would not be initialized.

How do I circumvent this?

P.S. I'm relatively new to C#

Answer 1

Let's start by defining what is static and what's the difference between static and instance members.

A static member is a member that doesn't need an instance to exist: it "belongs to the class", and not to an object (a instance of the class).

Now the readonly modifier, says that a member can only be assigned a value in the constructor (or in its declaration, but that's not relevant here).

There are two types of constructors: static constructors and instance constructors... the difference is the same difference as above, and the readonly modifier is of course, applied to each type of constructor: static readonly would mean "you can only change its value in the static constructor", and instance readonly would mean "you can change its value in the instance constructor".

The static constructor is called the first time the type is accessed, so it's always called first.

Now, in the examples you are just randomly changing members to static or not just to try if it compiles.

Think about it for a second... in the static context you have no instance at all, so it's just not possible to access instance members on the static constructors... furthermore, by the time the static constructor is called, there's no way you could have any initialized instance, even externally defined, since it'll always be called before you have the chance to initialize one.

So this line within the static constructor makes no sense:

c = new Apple(b.getDna());

You are trying to access b, which is an instance member, but you are not saying which instance should you get the value from.

You should really rethink your design, and think why members would be static or not, not just "move things around and try to make it compile and run".

Answer 2

The error message is in fact correct.

First, static means it belongs to the class. Non static means it is per instance. An instance method can modify a static variable, but a static method cannot modify an instance variable (which instance would it modify?)

Given that, readonly means you can only initialize during creation (e.g. constructor.)

You are getting the error because you are trying to assign a readonly static AFTER its creation in an instance constructor.

Answer 3

The error is correct because if you create another instance of SomeClass the static field a will be assigned twice, against the readonly constraint.

Answer 4

You are trying to assign values to read only static variables inside a instance constructor. At the point you call the instance constructor that variables are already assigned a value, which is null.

public SomeClass()
{
    a = new Apple(); // it is already assigned as null. 
    b = new Orange(a.getDna()); //there is no value assigned to it yet
    c = new Apple(b.getDna()); //it is already assigned as null
}

This happens because the static constructor is called before the instance constructor. You can have more details here:

A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.

But then, you have the problem when you are trying to access an instance variable inside the static constructor. At that point, the instance constructor is not yet called, which means your variable b is not yet initialized.

You are facing a very common problem, where you are trying to mix instance variables and static variables. This approach can lead to very strange behaviours, like the one you are facing.

I suggest to you to don't mix this variables, make them all static or or make them all instance, but don't mix it. Otherwise, you might face different problems in the near future

Answer 5

Is there a wrong warning here?

No. The warning is correct. If a field is readonly, we can assign it a value in two places: upon declaration or in the constructor. Further, if something is static, its associated constructor is static too. So, we can assign to a static and readonly field in two places:

1. Upon declaration or
2. in the static constructor.

We cannot do it in an instance constructor.

Your other question is about the inability of a static field to depend on an instance one.

How do I circumvent this?

Here is a creative way to circumvent it:

1. In the static constructor, assign to static _b.
2. In the instance constructor, assign the static _b to the instance's b.

We can even assign _b = null when we're done with it and still access the value that we earlier assigned to b.

Here is an example:

public class SomeClass
{
    private static readonly Apple a, c;
    private static Orange _b;
    private readonly Orange b;

    static SomeClass()
    {
        a = new Apple();        
        _b = new Orange(a.getDna());
        c = new Apple(_b.getDna());
    }

    public SomeClass()
    {
        b = _b;
        _b = null;
    }

    //
    // the rest is just class definitions
    //      

    public class Apple
    {
        public Apple(object o = null) {}
        public object getDna() { return new object(); }
    }

    public class Orange
    {
        public Orange(object o = null) { }
        public object getDna() { return new object(); }
    }
}

It does let you circumvent the problem.