Sunday, November 24, 2019

Tuple patterns in C# 8


Hello everyone. Today I want to show you a new feature in C# 8 called Tuple patterns. After more than two-year break, I have decided that it’s high time to resurrect my blog. So, let’s talk what is the tuple pattern and what the problem this pattern solving. Tuple patterns ⎼ some algorithms depend on multiple inputs. Tuple patterns allow you to switch based on multiple values expressed as a tuple. The following code shows a switch expression for the game rock, paper, scissors (I’ve grabbed this code from What's new in C# 8.0 documentation):
public static string RockPaperScissors(string first, string second)
=> (first, second) switch
{
    ("rock", "paper") => "rock is covered by paper. Paper wins.",
    ("rock", "scissors") => "rock breaks scissors. Rock wins.",
    ("paper", "rock") => "paper covers rock. Paper wins.",
    ("paper", "scissors") => "paper is cut by scissors. Scissors wins.",
    ("scissors", "rock") => "scissors is broken by rock. Rock wins.",
    ("scissors", "paper") => "scissors cuts paper. Scissors wins.",
    (_, _) => "tie"
};
If you see in existing code, we used tuple pattern to compare a pair of strings and return string as a result. For example, for strings “rock” and “paper” we will return a new string “rock is covered by paper. Paper wins.” So, let’s take a look how it works under the hood. (Below you will find IL code with further explanation how this code works)
.method public hidebysig static
    string RockPaperScissors (
        string first,
        string second
    ) cil managed
{
    // Method begins at RVA 0x2078
    // Code size 206 (0xce)
    .maxstack 2
    .locals init (
        [0] string,
        [1] string
    )

    IL_0000: ldarg.0
    IL_0001: brfalse IL_00c2

    IL_0006: ldarg.0
    IL_0007: ldstr "rock"
    IL_000c: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0011: brtrue.s IL_0032

    IL_0013: ldarg.0
    IL_0014: ldstr "paper"
    IL_0019: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_001e: brtrue.s IL_0054

    IL_0020: ldarg.0
    IL_0021: ldstr "scissors"
    IL_0026: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_002b: brtrue.s IL_0073

    IL_002d: br IL_00c2

    IL_0032: ldarg.1
    IL_0033: brfalse IL_00c2

    IL_0038: ldarg.1
    IL_0039: ldstr "paper"
    IL_003e: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0043: brtrue.s IL_0092

    IL_0045: ldarg.1
    IL_0046: ldstr "scissors"
    IL_004b: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0050: brtrue.s IL_009a

    IL_0052: br.s IL_00c2

    IL_0054: ldarg.1
    IL_0055: brfalse.s IL_00c2

    IL_0057: ldarg.1
    IL_0058: ldstr "rock"
    IL_005d: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0062: brtrue.s IL_00a2

    IL_0064: ldarg.1
    IL_0065: ldstr "scissors"
    IL_006a: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_006f: brtrue.s IL_00aa

    IL_0071: br.s IL_00c2

    IL_0073: ldarg.1
    IL_0074: brfalse.s IL_00c2

    IL_0076: ldarg.1
    IL_0077: ldstr "rock"
    IL_007c: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0081: brtrue.s IL_00b2

    IL_0083: ldarg.1
    IL_0084: ldstr "paper"
    IL_0089: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_008e: brtrue.s IL_00ba

    IL_0090: br.s IL_00c2

    IL_0092: ldstr "rock is covered by paper. Paper wins."
    IL_0097: stloc.0
    IL_0098: br.s IL_00ca

    IL_009a: ldstr "rock breaks scissors. Rock wins."
    IL_009f: stloc.0
    IL_00a0: br.s IL_00ca

    IL_00a2: ldstr "paper covers rock. Paper wins."
    IL_00a7: stloc.0
    IL_00a8: br.s IL_00ca

    IL_00aa: ldstr "paper is cut by scissors. Scissors wins."
    IL_00af: stloc.0
    IL_00b0: br.s IL_00ca

    IL_00b2: ldstr "scissors is broken by rock. Rock wins."
    IL_00b7: stloc.0
    IL_00b8: br.s IL_00ca

    IL_00ba: ldstr "scissors cuts paper. Scissors wins."
    IL_00bf: stloc.0
    IL_00c0: br.s IL_00ca

    IL_00c2: ldstr "tie"
    IL_00c7: stloc.0
    IL_00c8: br.s IL_00ca

    IL_00ca: ldloc.0
    IL_00cb: stloc.1
    IL_00cc: ldloc.1
    IL_00cd: ret
} // end of method Program::RockPaperScissors

On the surface, there is a lot of IL code here which is hard to understand. But we can take a look more deeply at this code and split this code to the simple logical blocks.
IL_0000: ldarg.0
    IL_0001: brfalse IL_00c2

    IL_0006: ldarg.0
    IL_0007: ldstr "rock"
    IL_000c: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0011: brtrue.s IL_0032

    IL_0013: ldarg.0
    IL_0014: ldstr "paper"
    IL_0019: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_001e: brtrue.s IL_0054

    IL_0020: ldarg.0
    IL_0021: ldstr "scissors"
    IL_0026: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_002b: brtrue.s IL_0073

    IL_002d: br IL_00c2

The first line of code loads the argument at index 0 into the evaluation stack. The next line allows to transfer control to a target instruction if value is false, a null reference or zero. If this check instruction returns false for us, then compiler navigates to IL_00c2. Below you will find how this label looks like.
    IL_00c2: ldstr "tie"
    IL_00c7: stloc.0
    IL_00c8: br.s IL_00ca
From development perspective this IL instruction works like goto statement.
public static string RockPaperScissors(string first, string second)
{
    if (first == null)
        goto NotFound;

NotFound:
    return "tie";
}
If the first instruction does not return null, the compiler loads the arguments at index 0. This instruction will check the first argument “rock” using equality operator
    IL_0006: ldarg.0
    IL_0007: ldstr "rock"
    IL_000c: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0011: brtrue.s IL_0032
If the first argument (in our case the parameter first) called “rock” compiler creates an instruction to navigate to label IL_0032. I will post bellow the information about IL_0032 label.
    IL_0032: ldarg.1
    IL_0033: brfalse IL_00c2

    IL_0038: ldarg.1
    IL_0039: ldstr "paper"
    IL_003e: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0043: brtrue.s IL_0092

    IL_0045: ldarg.1
    IL_0046: ldstr "scissors"
    IL_004b: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0050: brtrue.s IL_009a

    IL_0052: br.s IL_00c2
Here at the first line the compiler downloads the second argument from stack and checks this argument to null value. If this value is equal to null, we will jump to IL_00c2 label and return “tie” result. In example below I will try to show how this result will look in C# code.
public static string RockPaperScissors(string first, string second)
{
    if (first == null)
        goto NotFound;

    if(first.Equals("rock"))
        goto IL_0032;
   
IL_0032:

    if (second == null)
        goto NotFound;

NotFound:
    return "tie";
}
In the second operation, we are checking equality to value “paper”. If the second argument is equal to “paper”, the compiler creates an instruction to navigate to IL_0092 label and returns string “rock is covered by paper. Paper wins.”
IL_0092: ldstr "rock is covered by paper. Paper wins."
    IL_0097: stloc.0
    IL_0098: br.s IL_00ca
If the previous check returns false, the compiler checks the second instruction from stack and compares this argument with “scissors”
    IL_0045: ldarg.1
    IL_0046: ldstr "scissors"
    IL_004b: call bool [mscorlib]System.String::op_Equality(string, string)
    IL_0050: brtrue.s IL_009a
If this checking result returnes true, we will jump to label IL_009a and return value “rock breaks scissors. Rock wins.”
IL_009a: ldstr "rock breaks scissors. Rock wins."
    IL_009f: stloc.0
    IL_00a0: br.s IL_00ca
Otherwise, the next call IL_0052: br.s IL_00c2 will jump us to exit and return “tie” from method. Ok, I will propose to see how this code will be mapped to C#.
public static string RockPaperScissors(string first, string second)
{
    if (first == null)
        goto NotFound;

    if(first.Equals("rock"))
        goto IL_0032;
   
IL_0032:

    if (second == null)
        goto NotFound;

    if (second.Equals("paper"))
        goto IL_0092;

    if (second.Equals("scissors"))
        goto IL_009a;

IL_0092:
    return "rock is covered by paper. Paper wins.";
IL_009a:
    return "rock breaks scissors. Rock wins.";
NotFound:
    return "tie";
}
You see, that is something like a jump table or simple state machine. Other checking for “rock” and “scissors” just adds additional labels for jumping. I would suggest taking a look at the C# projection for our IL code with updating label names to a readable format.
public static string RockPaperScissors(string first, string second)
{
    if (first == null)
        goto NotFound;

    if(first.Equals("rock"))
        goto ROCK;

    if (first.Equals("paper"))
        goto PAPER;

    if (first.Equals("scissors"))
        goto SCISSORS;

ROCK:

    if (second == null)
        goto NotFound;

    if (second.Equals("paper"))
        goto rock_is_covered_by_paper;

    if (second.Equals("scissors"))
        goto rock_breaks_scissors;

PAPER:

    if (second == null)
        goto NotFound;

    if (second.Equals("rock"))
        goto paper_covers_rock;

    if (second.Equals("scissors"))
        goto paper_is_cut_by_scissors;

SCISSORS:

    if (second == null)
        goto NotFound;

    if (second.Equals("rock"))
        goto scissors_is_broken_by_rock;

    if (second.Equals("paper"))
        goto scissors_cuts_paper;

rock_is_covered_by_paper:
    return "rock is covered by paper. Paper wins.";
rock_breaks_scissors:
    return "rock breaks scissors. Rock wins.";
paper_covers_rock:
    return "paper covers rock. Paper wins.";
paper_is_cut_by_scissors:
    return "paper is cut by scissors. Scissors wins.";
scissors_is_broken_by_rock:
    return "scissors is broken by rock. Rock wins.";
scissors_cuts_paper:
    return "scissors cuts paper. Scissors wins.";
NotFound:
    return "tie";
}

When we look more precisely at this C #code, we can split this code into four states (state machine). 
In state 0 we have the basic logic for checking the first argument. The State number one shows how state machine works when we check “rock” parameter.
The state number two does the same for “paper” validation
And the last state 3, where we will check “scissors” validation.
So, as you see, as much parameters you will add, as more complex state machine will be created. I find this feature very useful and it will help to develop a new functionality in less time using C# language.

Wednesday, December 28, 2016

Цели и планы на 2017 год

Пришло самое время подвести итоги 2016 года и проверить, сумел ли я достичь тех целей, которые ставил себе в 2015 году.
Итак, первый вопрос – по поводу самого блога. Вероятнее всего, буду писать статьи только на английском. Наверное, придётся пойти на такой шаг, чтобы улучшить практический письменный язык, заодно, надеюсь, этот шаг будет больше привлекать иностранную аудиторию. В целом за этот год я написал 12 статей. Это в три раза меньше, чем количество статей в 2015 году. Создание нормальной статьи для блога, начиная от идеи, написания рабочего примера и оформления этого в отдельную статью (а потом эту смесь текста и кода отдать моей красавице жене на вычитку и исправление ошибок) – это очень громоздкая работа, поэтому я решил больше времени уделить самообучению в сфере web разработки и в английском. 
Что из этого вышло
Пройдено 30 курсов по разным технологиям и языкам, начиная с Angular 2, React, TypeScript, JabaScript и заканчивая деплойментом с Docker и Octopus.
Также каждый день уделял по 3-4 часа на изучене английского языка с помощью Lingualeo и Memrise. Весь пройдённый материал закреплял на работе на speaking clubs с прекрасными преподавателями, которым выражаю огромную благодарность за потраченное время. 
Я также продолжил дальше заниматься менторством. В этом году я обучил уже третью группу студентов таким темам, как паттерны проектирования, EntityFramework Code First и Repository & Unit Of Work patterns. Приятно наблюдать, что переданные знания успешно внедряются в рабочем проекте.
Ну и, пожалуй, самый авантюрный шаг, на который я решился в этом году, – это изучение французского. Я рассматриваю изучение нового языка как один из способов лучше понять английский, а также пробовать заставить себя мыслить на другом языке.
Вот план, поставленные в блоге на 2016 год:

  • Разобраться с OAuth и OWIN Forms аутентификацией.
  • Выучить глубоко JavaScript и TypeScript
  • ASP.NET vNext with Angular 2.0
  • Попробовать пройти сертификацию Developing ASP.NET MVC 4 Web Applications или даже всю цепочку MCSD: Web Applications.
  • C# 7
  • EntityFramework 7
  • DDD (Experimenting with CQRS and event driven design)
  • Mentoring
  • Read 20 books in English

Теперь, пожалуй, пройдусь по этим целям для самопроверки.
Разобраться с OAuth и OWIN Forms аутентификацией – с этой целью я успешно справился. Во-первых, у меня была возможность применить это все на практике, пускай и на пилотных проектах. Во-вторых, пройденный курс на pluralsight помог закрепить этот материал.
Выучить глубоко JavaScript и TypeScript – не знаю, насколько глубоко получилось выучить JavaScript, но как минимум писать сейчас на нем весь клиентский код для клиента не составляет никакого труда. Думаю, могу поставить эту цель как выполненную и продолжать улучшать знания в этой среде.  
ASP.NET vNext with Angular 2.0 – цель была ознакомиться с данными технологиями и фреймворком. С момента написания прошлой статьи ASP.NET vNext сменил свое название на ASP.NET Core, но это не помешало мне попробовать его на пилотном проекте и на своих проектах для блога. Angular 2 я по привычке использовал на своем классическом примере со студентами, но не уверен, что у меня будет время адаптировать этот проект для блога. В этом вопросе, наверное, я даже перевыполнил план, так как я успел много времени потратить на React, и все тот же проект со студентами переписать на него. Поэтому ставлю цель как выполненную.
Попробовать пройти сертификацию Developing ASP.NET MVC 4 Web Applications или даже всю цепочку MCSD: Web Applications. с этой целью я не справился. И, наверное, единственная для этого причина состоит в том, что я не захотел тратить 80$ за сертификат, от которого не вижу никакой пользы. Время на изучение ASP.NET MVC я все равно потратил, и думаю, что полученных знаний хватило бы для прохождения сертификации. Но цель все же не выполнена.
C# 7 – разобраться с C# 7 была самая легкая цель, которую я себе поставил. Я обожаю C# как язык программирования, поэтому эта цель была, наверное, самой приятной. Заодно сумел попробовать в работе VS 2017 и IDE от JetBrains под названием Rider. Цель как выполнена.
EntityFramework 7 – фреймворк, который с момента написания поменял свое название на EntityFramework Core. Успел попробовать его на практике, также завести багу разработчикам, доклад о которой они успешно проигнорировали и которая существует до сих пор. Цель выполнена, но вот фреймворк еще сырой и использовать его в production не рекомендую.
DDD (Experimenting with CQRS and event driven design) – неоднозначная цель. Был на ивентах, посвященных CQRD,  правда, единственное, что я делал на них, – это пытался показать, что CRUD модель иногда очень даже неплохо заменяет CQRS. На практике я так и не попробовал использовать Event Sourcing и не уверен, что у меня будет когда-то эта возможность. Заказчики очень боятся внедрять CQRS в свои системы, а я пока не вижу в нем особого преимущества. Надеюсь, мое виденье этого процесса изменится в будущем. Пока поставлю цель как частично завершенную.
Mentoring – в этом году у меня была возможность побывать ментором для двух групп студентов и прочитать по три лекции для каждой группы. План по менторству можно считать выполненным.
Read 20 books in English – последняя цель для меня была просто удовольствием. Из них технических книг было всего шесть и четырнадцать – в основном приключения и фантастика. Например, все коллекция книг о Властелине Колец и о Гарри Поттере. Так что цель можно считать завершенной.
Цели на 2017 год
Следующий год хочу посвятить на развитие навыков, необходимых для успешного созданий и проектирования программ, т.е. навыков, которые нужны для того, чтобы приблизиться к званию software architect.
  • Microsoft application architecture guide
  • AOP in .NET: Practical Aspect-Oriented Programming
  • DDD concepts
  • Enterprise integration patterns - designing, building, and deploying messaging solutions
  • UML Concepts
  • Basic layered architecture principles
  • The Synthesis of Solutions
  • Read 20 books in English
  • Выучить французский до уровня A2
Думаю, этих планов мне должно хватить на целый 2017 год. Бывает сложно мотивировать себя что-либо делать, начать это делать или не бросить запланированное на полпути. Присоединяйтесь к блогу, будем делать это вместе в виде соревнования. Желаю всем счастливого Нового года. Пусть он будет намного лучше, чем был уходящий, и чтобы он все ваши добрые пожелания и светлые мечты сбылись в этом году. Отдельное спасибо хочу сказать своей любимой жене и дочери, которые меня постоянно мотивируют изменяться в лучшую сторону. Я знаю, солнышко, что ты будешь читать эту статью перед публикацией. Спасибо тебе большое за то, что ты у меня есть и за то, что помогаешь мне во всех моих начинаниях. Я бы не хотел и не смог этого ничего сделать без тебя. 

Sunday, June 5, 2016

Обзор книги Мартина Фаулера "Patterns of Enterprise Application Architecture"

Наконец-то я смог себя пересилить и написать статью, над которой давно думал. (Лень, подготовка к новой для себя области и постоянное обучение не позволяли этого сделать.) Поделюсь с Вами мыслями по поводу книги Мартина Фаулера “Patterns of Enterprise Application Architecture”. На русском эта книга называется “Архитектура корпоративных программных приложений”, если у Вас возникнет желание ее прочитать. 
Как и во всех своих предыдущих рецензиях, выделю сначала плюсы и минусы книги, а затем перейду к более детальной субъективной критике.
Плюсы:
  • Обилие примеров и описание паттернов.
  • Перекрёстные ссылки с указанием страницы с описанием паттерна.
  • Язык примеров C# и Java что делает их многим доступным для понимания.

Минусы:
  • Некоторые паттерны описаны скудно в плане реализации.
  • Примеры сильно устарели.
  • Примеры, которые написаны на C#, полностью повторяют Java стиль
А теперь обо всем этом более подробно. Хотелось бы сказать, что книга стоит того, чтобы ее прочитать, хотя бы для того, чтобы структурировать свои знания. Я считаю эту книгу классикой, которую можно поставить на уровне “Банды четырех” (GOF) с их книгой “Design Patterns”, потому что эта книга дает базу и понятия, которые присущие в проектировании enterprise приложений. Как минимум, термины с этой книги вы можете использовать для общения с опытными разработчиками, и они будут вас понимать.
Фаулер, например, неплохо раскрывает такие паттерны, как Repository, Mapper, Active Record, Unit of Work и другие. К сожалению, в мире разработки архитектурных решений не так уж много книг, которые достойно описывают данную область без лишней “воды”. Когда читаешь эту книгу, как минимум радует, что когда встречается название паттерна, всегда есть ссылка на источник, где о нем можно почитать. Мне это очень помогало при сравнении и анализе глав книги. Ну и так как мой язык разработки – C#, а Java очень подобный к нему, эту книгу мне было очень легко воспринимать. Если вы не знакомы с этими языками, примеры понять будет посложнее.
А теперь пройдемся по негативным моментам книги. Я уважаю Мартина Фаулера как разработчика и архитектора, а также как автора книг, но хотелось бы обратить внимание на нюансы, которые мне не понравились в книге. И первый такой момент заключается в том, что в книге встречаются часто разные названия одного и того же паттерна. Например, коллизия с названием паттерна Value Object и Data Transfer Object.
Совпадение названий
На протяжении довольно долгого времени данное типовое решение носило название объекта-значения. К сожалению, несколько лет назад в сообществе J2EE [3] термин объект-значение (value object) стал применяться для обозначения типового решения объект переноса данных (Data Transfer Object, 419), что вызвало настоящую бурю среди разработчиков типовых решений. Подобная путаница с названиями — далеко не редкость в нашей сфере деятельности. Не так давно авторы книги [3] решили отказаться от использования термина "объект-значение" и заменили его термином объект переноса (transfer object). Я продолжаю использовать термин "объект-значение" в том смысле, в котором он применяется в контексте данной книги. По крайней мере, так я не вступаю в противоречие со своими предыдущими работами!
Сама идея того, что автор всюду использует Value Object, вроде, сама по себе и ничего, но когда ты смотришь примерь пример и понимаешь, что это классический в .NET DTO, в голове возникает много вопросов.
Взглянем на примеры книги. К сожалению, очень много из них устарели много лет назад. Например, глава Presentation Patterns пестрит изобилием кода для JSP, а код примеров на C# лучше не читать, чтобы не поплохело. Другой пример – это глава о паттернах Object-Relational Structural Patten, в которых все примеры приводились на ручном парсинге и выборке данных. Может быть, это и полезно для базы, но когда есть такие ORM, как EntityFramework или NHibernate, думаешь, зачем сколько кода постоянно дублировать и переписывать. Я не совсем понимал, почему так сложно приводить в примеры готовую реализацию. Или, может, в Java нет готовой реализации некоторых паттернов. Целая глава, которая посвящена Data Source Architectural Patterns, полностью реализована в .Net Framework. Тот же Table Data Gateway – это типичная реализация DataSet в ADO .NET, паттерн Row Data Gateway – типичная реализация Row в том же ADO .NET, то же самое – касательно Active Record и Data Mapper. Некоторые паттерны эволюционировали, и примеры с книги не показывают той элегантности, с которой эти паттерны можно использовать. На момент выхода книги, когда я прочитал несколько отзывов о ней, она уже была с неактуальной информацией.  
Так як книга 2002 року выпуска, не понимаю, почему в ней не раскрыты вопросы тестирования и Dependency Inversion, паттерны безопасности, почему нет банального Service Locator. Большинство примеров в книге написаны так, что они не поддаются тестированию. Как говорят программисты, “на коленке” написан код. То есть, о части материала с книги можно много дискутировать с коллегами на работе или просто с друзьями по интересам.
Мой самый нелюбимый момент в книге – примеры на двух языках. Проблема не в самих примерах, они в большинстве неплохие, но некоторые очень маленькие и тривиальные, что недостаточно для раскрытия сути. Плохо, что стиль Java примеров, переходит на стиль написания C#. То есть, все примеры на C# написаны в стиле именования Java. Но это мое субъективное мнение.
Итоги
Несмотря на свой возраст, эта книга является незаменимой основой, и  любому разработчику выше среднего уровня было бы полезно ее прочитать. Реальное понимание идеи книги приходит, если вы начинаете понимать, как эти идеи развивались с течением времени. Мартин Фаулер пишет в основном по сути, и в этой книге немного “воды”, которую часто любят лить архитекторы, когда начинают мыслить на страницах книги о высоком, не передавая конкретной сути. Я отнес бы эту книгу в категорию “should read”, то есть книгу, которую следовало бы прочесть. Моя оценка данной книги – 4 балла из 5 возможных.