CQRS Journey

Решил ознакомиться с результами трудов P&P и был приятно удивлен! В кое то веки P&P выпустило что-то стоящее :) Пусть это не замена всем остальным разбросанным по просторам интернета знаниям о DDD/CQRS/ES, но для начального ознакомления очень даже подойдет. Продолжаю читать.

Expression.Property breaking change in .NET 4.0

Если вы переезжаете на .NET 4.0 и используете expression trees то возможно вас заинтересует, что раньше такой код был валиден и для статических свойств:

var comparerExpr = Expression.Property(Expression.Constant(comparerType), comparerProperty);

Теперь же требуется дополнительная проверка:

var comparerExpr = Expression.Property(isStatic ? null : Expression.Constant(comparerType), comparerProperty);

Все дело во внутренностях метода Expression.Property!

Было:

public static MemberExpression Property(Expression expression, PropertyInfo property)

{

    if (property == null)

    {

        throw Error.ArgumentNull("property");

    }

    if (!property.CanRead)

    {

        throw Error.PropertyDoesNotHaveGetter(property);

    }

    if (!property.GetGetMethod(true).IsStatic)

    {

        if (expression == null)

        {

            throw Error.ArgumentNull("expression");

        }

        if (!AreReferenceAssignable(property.DeclaringType, expression.Type))

        {

            throw Error.PropertyNotDefinedForType(property, expression.Type);

        }

    }

    return new MemberExpression(expression, property, property.PropertyType);

}

Стало:

public static MemberExpression Property(Expression expression, PropertyInfo property)

{

    ContractUtils.RequiresNotNull(property, "property");

    MethodInfo info = property.GetGetMethod(true) ?? property.GetSetMethod(true);

    if (info == null)

    {

        throw Error.PropertyDoesNotHaveAccessor(property);

    }

    if (info.IsStatic)

    {

        if (expression != null)

        {

            throw new ArgumentException(Strings.OnlyStaticPropertiesHaveNullInstance, "expression");

        }

    }

}

"Лишние" ссылки в проектах

Известно что «лишняя» ссылка из проекта А в проект В в результате компиляции не попадет в A.dll – об этом позаботится компилятор. Казалось бы ну и нет проблемы. Однако с точки зрения билд-процесса эта «лишняя» ссылка существует и поэтому если у вас изменились исходные файлы в проекте В, то будет перестроен и он и проект А, даже если последний не менялся. Так что для ускорения билдов неплохо было бы подчистить эти «лишние» ссылки. Для этого можно воспользоваться R#-ом и его «Optimize references».

Все сказанное помогает «нормальным» проектам. Нормальные проекты - это проекты, чье дерево зависимостей между проектами выглядит «широким», то есть имеет много «листовых», ни от кого независящих проектов. Если же у вас есть одна сборка Помойка.dll, от которой зависит большинство остальных сборок (таким образом ваше дерево проектов выглядит как Александрийский столп), то вы сами себе буратины – можете ходить и пить кофе на каждый билд.

P.S. Дерево проектов и его ширину-глубину можно посмотреть в билд-логе под расширенным логгированием.

О валидации доменных объектов

Читаю эту старую, но не потерявшую популярность, книжку и не перестаю удивляться как давно люди пишут про "качество кода": ортогональность, high cohesion/low coupling и т.д. Все эти разговоры какие-то "неземные" - в реальной жизни приходится постоянно сталкиваться с трудностями в базовых вещах вокруг ООП...

Частая ситуация, с которой приходится сталкиваться, это невалидные данные при сохранении сущностей: это может быть сработавший constraint в базе, а может вы это обнаружите уже при вычитывании сущностей... Для примера рассмотрим такую "доменную" модель:

class Rectangle
{
    public int Height { get; set; }
    public int Width { get; set; }

    public int Area()
    {
        return Height * Width;
    }
}

class Square : Rectangle
{
}

В нашем примере проблема состоит в том, что в базе оказываются "квадраты" с разными сторонами. Проблему можно "решить" разными способами, например так:

class Rectangle
{
    public virtual int Height { get; set; }
    public virtual int Width { get; set; }

    public int Area()
    {
        return Height * Width;
    }
}

class Square : Rectangle
{
    private int _lengthOfSide;

    public override int Height
    {
        get
        {
            return _lengthOfSide;
        }
        set
        {
            _lengthOfSide = value;
        }
    }

    public override int Width
    {
        get
        {
            return _lengthOfSide;
        }
        set
        {
            _lengthOfSide = value;
        }
    }
}

Проблемы с "пуговицами", то есть с нецелостными данными в базе, уйдут, зато появятся другие... Достаточно быстро мы придем к идее валидации объекта перед его сохранением:

class Rectangle
{
    public int Height { get; set; }
    public int Width { get; set; }

    public int Area()
    {
        return Height * Width;
    }

    public virtual void Validate()
    {
    }
}

class Square : Rectangle
{
    public override void Validate()
    {
        base.Validate();

        if (Height != Width)
        {
            throw new InvalidProgramException("Height and Width must be equal!");
        }
    }
}

Проблема вроде бы решена, остается выбрать бросать исключение или, например, получать от метода коллекцию ошибок валидации для более удобного отображения информации пользователю. Однако есть несколько моментов:

1. Наличие метода Validate "подрывает" наше доверие к объектам, подталкивает к тому, чтобы вызывать его постоянно, "на всякий случай". В случае больших сущностей и большого набора правил валидации это может быть накладно. После этого мы конечно же придумаем механизм оптимизации...
2. Результат валидации бесполезен! Как так? Ну а что толку в том, что перед сохранением объекта мы узнали что он невалиден? Сохранить об этом запись в логе и бросить исключение - вот все что мы можем. Мы не знаем когда объект стал невалидным, а если это "развесистый" объект с десятком свойств, который по пути к нам пересек несколько границ процессов, то шансов найти то самое место в коде, где на самом деле произошла ошибка, становится практически нереальным. Получив подобную ошибку с "живой" площадки мы с большой вероятностью либо закроем ее как unable to reproduce либо она вечно будет висеть в состоянии open.

Что если бы мы падали с исключением и записью в логе в тот самый момент, когда пытались привести объект в невалидное состояние? Хотя бы так:

class Rectangle
{
    public int Height { get; private set; }
    public int Width { get; private set; }

    public int Area()
    {
        return Height * Width;
    }

    public virtual void Resize(int height, int width)
    {
        Height = height;
        Width = width;
    }
}

class Square : Rectangle
{
    public override void Resize(int height, int width)
    {
        if (height != width)
        {
            throw new ArgumentException("Height and Width must be equal!");
        }

        base.Resize(height, width);
    }
}

Идея проста: не надо валидировать доменные объекты, надо недопускать их невалидного состояния! Причем здесь ООП? При том что мы не дали внешнему коду менять состояние нашего объекта, а спрятали это действие и связанные с ним правила внутрь метода объекта. Не это ли называется инкапсуляцией?

P.S. Предвижу вопроcы типа "наши пользователи редактируют объекты как хотят, а мы должны подсвечивать неправильные данные". Ответ прост - то что пользователи видят и редактируют это совсем не доменные объекты...

Persistence Model vs. Domain Model

Excelent article about how to map your domain model into persistence model avoiding "model replication".

О доменной модели...

Допустим в вашем приложении есть три модуля: модуль управления профилем пользователей, модуль формирования-оплаты заказов и модуль доставки заказов. Выглядела бы так в вашей доменной модели сущность "Покупатель"?

Customer
{
    FirstName
    LastName
    DateOfBirth
    ShippingAddress
    CreditCardNo
    BillingAddress
    WishList
}

Эволюция кода

Как получает так, что в целом неплохой код со временем становится помойкой, клубком проблем, Авгиевыми конюшнями и ящиком Пандоры all-in-one?

The Broken Window Theory

A window gets broken at an apartment building, but no one fixes it. It's left broken. Then something else gets broken. Maybe it's an accident, maybe not, but it isn't fixed either. Graffiti starts to appear. More and more damage accumulates. Very quickly you get an exponential ramp. The whole building decays. Tenants move out. Crime moves in. And you've lost the game. It's all over.

Аналогично и с программированием. Вы написали код, хороший код, почти идеальный. От "почти" до идеала вас отделила какая то мелочь. То ли не вовремя закончился рабочий день, а с ним и вдохновение, то ли не кстати появилась критическая проблема, которую срочно нужно было решать. В конце концов мы не идеалисты, мы реалисты! И, черт побери, этот код работает, что еще нужно?!

Прошло время и оказалось что кому то в вашем идеальном коде не хватило той самой мелочи, например точки расширения. Будучи то ли слишком скромным, то ли слишком самостоятельным, этот кто то отвлекать вас не стал, а сам добавил в один из ваших базовых классов какой то метод для своих целей. Прошло еще время и этот метод стал использоваться во многих местах вашего и не только вашего кода. Заодно этот метод обзавелся "соседями" - другими методами на всякие другие случаи жизни. Ваш код заматерел, оброс методами-"мясом", однако оригинальная цель и идея уже не так явно просматривается в этом наборе методов "на-все-случаи-жизни". Зато у многих ваших коллег есть четкое понимание куда нужно добавлять новые методы-помощники, если вдруг такие понадобятся. Взамен вы лишились возможности навести в, когда то вашем, коде порядок, потому что теперь вы связаны по рукам и ногам совместимостью, связанностью и т.д.

Поздравляю! Вы очередной автор очередного г..нокода!

Что такое "чистый код"?
Как улучшить плохой код?
Почему чистый код часто "портится"?
Почему в написании кода так важны мелочи?

Читаем Роберт Мартин "Чистый Код"!