H_D>      - Долгая история. Все дело в том, что местные программисты пошли
H_D>по неверному пути. Этот путь называется объектно ориентированный подход
H_D>в программировании. На самом деле это мина с часовым механизмом в
H_D>красивой упаковке. В очень красивой упаковке. Как с этим бороться, я
H_D>не знаю. Упустил момент.
H_D>      - Мастер, ближе к делу.
H_D>      - Знаешь анекдот, как программист кипятит чайник. Дано: пустой
H_D>чайник, кран, спички, газовая плита. Программа действий: наполнить
H_D>чайник водой из-под крана, поставить на плиту, зажечь газ. Ждать, пока
H_D>закипит чайник. Эта программа оформляется как объект. Второй случай.
H_D>Все то же самое, но чайник с водой уже стоит на плите. Действия
H_D>программиста: вылить воду из чайника и выполнить предыдущий объект.
H_D>      - Грустно. А нырнуть внутрь объекта нельзя? Туда, где надо газ
H_D>зажечь?
H_D>      - Нельзя. Можно добавить новое свойство или действие. В нашем случае
H_D>- воду вылить. Будет новый объект. Но внутрь влезть нельзя. Объект дается
H_D>как единое целое. Никто не знает, что там внутри. Все давно забыли, откуда
H_D>ноги растут. В результате получается колоссальное дублирование кода и данных
H_D>и огромная потеря производительности компьютера. С каждым годом компьютеры
H_D>требуют все больше памяти, а работают все медленнее.
H_D>

функция _Главная_
{
    _Чайник_ экземпляр как _Чайник_с_водой_
    _Устройство_для_кипячения_::_Кипятить_(экземпляр) 
}


_Устройство_для_кипячения
{
    функция _Кипятить_(_Чайник_ экземпляр)
    {
        если (экземпляр есть _Чайник_с_водой_)
            кипятить
        другое
            пошел взад
    }
}

ВВ>Налицо неумелое проектирование. _Чайник_ должен быть представлен как отдельный объект, _Вода_ также как отдельный объект. _Чайник_с_водой_ представляет собой объект, отнаследованный от объектов _Чайник_ и _Вода_.

public abstract class Content
{
    public vitual double Weight
    {get;}
    
    public vitual double Volume
    {get;}
}

public abstract class LiquidContent : Content
{
    public vitual double BoilTemperature
    {get;}
    
    public bool IsBoiled
    {
        get
        {
            return _temperature >= DoilTemperature;
        }
    }
}

public class WaterContent
{
    public WaterContent(double count) {...}

    public override double BoilTemperature
    {
        get { return 100f; }
    }
}

public interface IContentProvider
{
    Content GetContent(double count);
}

public class Tap : IContentProvider
{
    WaterContent GetWater(double count)
    {
        try
        {
            _waterPipe.QueryWater(count);
        catch (WaterAbortedBySomebodyException)
        {
            throw new NoWaterInTapException("Воду выпили жиды");
        }
    }

    Content IContentProvider.GetContent(double count)
    {
        return GetWater(count);
    }
}

public interface IContentContainer
{
    double ContentRoom
    {get;}
    
    void PutContent(LiquidContent content);
}

public class Teapot : IContentContainer
{
    public double ContentRoom {...}
    
    public void PutContent(LiquidContent content)
    {
        if (content.Volume > (ContentRoom - _alreadyContained))
            throw new OverflowException();
        _alreadyContained += content.Volume;
    }
}

public interface IFireable
{
    bool IsFired
    {get;}

    void Fire(FireSource source);
}

public abstract class FireSourceProvider
{
    public abstract FireSource CreateFireSource();
}

public abstract class FireSource : IFireable
{
    protected abstract IsFired
    {get;}
    
    public abstract void Fire(FireSource source);
    
    public bool DoFire(IFireable what)
    {
        while (!what.IsFired)
        {
            what.Fire(this);
            if (IsFired)
                return false;
        }
        return true;
    }
}

public class Match : FireSource
{
    public override bool IsFired
    {
        get { return _isFired; }
    }
    
    public override void Fire() {...}
}

public class MatchBox : FireSourceProvider
{
    public override FireSource CreateFireSource()
    {
        if (_matchCount = 0)
            throw new NotEnoughMatchesException();
        _matchCount--;
        return new Match();
    }
}

public class Stove : IFireable
{
    public bool IsFired
    {
        get { return _isFired; }
    }
    
    public void Fire()
    {
        ...
        _isFired = true;
    }
    
    public void PutOn(object what)
    {
        ...
    }
}

const double overflowPreventVolume = 0.05f;
Teapot teapot = Home.Instance.Kitchen.PlatesAndDishesShelf.Extract("Teapot #1");
double requiredContentCount = teapot.ContentRoom - teapot.Content.Volume - overflowPreventVolume;
if (requiredContentCount > 0)
    teapot.PutContent(Home.Instance.Kitchen.Tap.GetContent(requiredContentCount));
MatchBox matchBox = Home.Instance.Kitchen.SmallShelf.Extract("MatchBox");
Stove stove = Home.Instance.Kitchen.Stove;
while (!stove.IsFired)
{
    int atemptCount = 0;
    const totalAtempts = 10;
    FireSource match = matchBox.CreateFireSource();
    while (!match.IsFired)
    {
        match.Fire(null);
        atemtpCount++;
        if (atemptCount > totalAtempts)
            throw new ArgumentException("Черт побери, какого фига спички мокрые!");
    }
    match.DoFire(stove);
}
stove.PutOn(teapot);
const int checkInterval = 30000;
while (!teapot.Content.IsBoiled)
    System.Threading.Sleep(checkInterval);

type TMainObject = class
private
...
public
  procedure DoEverything; virtual; // override this if you need to do something else
end;

H_D>Которая лишь подтверждает мысль, что ООП везде — это вред и блед, хотя и не отрицает что в бизнес приложениях ООП — это просто круто

type
    Чайник = class()
    private
        procedure НалитьВоды();
        procedure ПоставитьНаПлиту()
        procedure ЗажечьГаз();
        function ЖдатьКогдаЗакипит(): Boolean;
    public
        procedure Кипятить();
    end;
    
procedure Чайник.Кипятить();
begin
    НалитьВоды();
    ПоставитьНаПлиту()
    ЗажечьГаз();
    repeat
    until ЖдатьКогдаЗакипит();
end;