public abstract class Base
{
public Base()
{
Foo();
}
public virtual void Foo()
{
}
}
public class Derived : Base
{
private readonly string value;
public Derived(string value)
{
this.value = value;
}
public override void Foo()
{
base.Foo();
Console.WriteLine(value.Length);
}
}
Известно и решение для случая, когда менять базовый класс нельзя или не хочется - добавить в тушку проблемного метода в наследнике проверку на флаг инициализации:public class Derived : Base
{
private readonly string value;
private readonly bool inited;
public Derived(string value)
{
this.value = value;
inited = true;
}
public override void Foo()
{
base.Foo();
if (!inited)
return;
Console.WriteLine(value.Length);
}
}
Однако проблема тут куда шире. Дело, естественно, нихуя не в виртуализации, а в том, что ссылка на недоинициализированный объект отправляется во всеобщий доступ. А сделать такую хрень можно совершенно разными путями. Например, через explicit-реализацию интерфейса:
public interface ISome
{
void Foo();
}
public abstract class Base : ISome
{
public Base()
{
((ISome)this).Foo();
}
void ISome.Foo()
{
}
}
public class Derived : Base, ISome
{
private readonly string value;
public Derived(string value)
{
this.value = value;
}
void ISome.Foo()
{
Console.WriteLine(value.Length);
}
}
Решарпер тут уже ничего не говорит. А вот еще примерчик, вообще без наследования:public interface ISome
{
void Foo(ClassA classA);
}
public sealed class ClassA
{
private readonly string value;
public ClassA(ISome some, string value)
{
some.Foo(this);
this.value = value;
}
public void Goo()
{
Console.WriteLine(value.Length);
}
}
public sealed class ClassB : ISome
{
public void Foo(ClassA classA)
{
classA.Goo();
}
}
Если попробовать создать экземпляр ClassA и передать туда первым аргументом ClassB, получим все то же NRE. Причем в отличие от случая с наследованием, где можно обойти кривожопость базового класса, тут нельзя сделать вообще нихуя, потому что в общем случае никакой возможности узнать, проинициализировался ли базовый класс, нет. Еще один пример для коллекции:public static class StaticClass
{
public static void Goo(Base a)
{
a.Foo();
}
}
public class Base
{
public Base()
{
StaticClass.Goo(this);
}
public virtual void Foo()
{
}
}
public class Derived : Base
{
private readonly string value;
public Derived(string value)
{
this.value = value;
}
public override void Foo()
{
base.Foo();
Console.WriteLine(value.Length);
}
}
И еще:public interface ISome
{
void Foo();
}
public class ClassA : ISome
{
private readonly string value;
private readonly ClassB b = new ClassB();
public ClassA(string value)
{
b.Hoo(this);
this.value = value;
}
public void Foo()
{
Console.WriteLine(value.Length);
}
}
public class ClassB
{
public void Hoo(ISome i)
{
i.Foo();
}
}
Короче, разнообразие велико.Естественно, в жизни эти схемы куда более сложные. Они могут состоять из десятков объектов, включать в себя разруливание экземпляров через IoC-контейнеры или вообще передачу ссылок через unmanaged-код. Проблема тоже может всплыть не сразу, а уже после появления всей ссылочной сети. И разрулить ее в этот момент может оказаться нихуево долго и дорого.
Спастись от таких проблем с гарантией можно лишь одним способом - ввести запрет