class Bus<T>
{
static Bus()
{
foreach(FieldInfo fi in typeof(T).GetFields())
{
if(fi.FieldType == typeof(Argument))
{
fi.SetValue(typeof(T), new Argument("busyname", "busyvalue"));
}
}
}
}
class Buss : Bus<Buss>
{
public static Argument field;
}
Any ideas how to make this work so that a reference to the static field in Buss triggers the static constructor in Bus?
The fact that this matters to you probably means that you are using static constructors wrong.
With that in mind, you could make a static constructor in Buss that manually invokes the static constructor in Bus. Note that it's not possible to run a static constructor more than once.
The static constructor of a generic type is invoked exactly once per Type, when that type is referenced.
Calling Buss x = new Buss() will invoke the static constructor of Bus<Buss>.
Calling Bus<Buss> x = new Bus<Buss>() will also invoke the static constructor of Bus<Buss>, but it will do so for it's type argument Buss, setting Buss.field.
If you create a class Bugs : Bus<Buss> it will never set Bugs.field, as it will first resolve the type argument Buss, which invokes the static constructor of it's base class Bus<Buss>, setting Buss.field. When it tries to call the static constructor of Bugs base class, it will think it had already invoked the static Bus<Buss> constructor and skip it.
Basically if I copy paste your code, create a dummy Argument class and create a new instance of Buss, the static constructor is invoked and Buss.field is set to an instance of Argument, but I do recognize some strange behavoir here in which I'd have to advise not to use reflection from a static method to reach subclasses' statics.
The example you provided only works because Buss is the type argument for itself.
MSDN says that 'Static constructors are not inherited'. I guess this is similar to static fields which are not inherited either.
class T1{ public static string s1="s1"; } class T2: T1 { void f(){ Console.WriteLine(s1); }}. Does that not count as inheritance? One could legitimately expect that the static constructor of a base class is executed before the static constructor of one of its subcclasses is executed, since it may perform static initializations needed by the derived class as well.