'private static readonly' fields and static/nonstatic constructors

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.

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

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

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.