Занимательный C#. Пять примеров для кофе-брейка

Обратим внимание, что SDummy – это структура, реализующая интерфейс IDisposable, благодаря чему переменные типа SDummy можно использовать в блоке using.

Согласно MSDN оператор using во время компиляции разворачивается в try-finally блок. Поскольку структура не может быть null, наш using развернется в следующий код:

    try
    {
        Console.WriteLine(d.GetDispose());
    }
    finally
    {
        ((IDisposable)d).Dispose();
    }

Итак, в нашем коде внутри блока using вызывается метод GetDispose(), который возвращает булевское поле _dispose, значение которого для объекта d еще нигде не было задано (оно задается только в методе Dispose(), который еще не был вызван) и поэтому возвращается значение по умолчанию, равное False. Что дальше?

Заметим, что в строке:

((IDisposable)d).Dispose();

происходит упаковка (boxing) переменной d, т.к. SDummy – это значимый тип (value type) (о подробностях можно почитать, например, тут).

А это означает, что метод Dispose вызывается уже для другого объекта, а вовсе не для объекта d! Соответственно, значение у поля _dispose для объекта d не поменяется и второй раз на консоль также будет выведено False.

Таким образом, метод Main выведет на консоль «False False», а не «False True», как считают многие из тех, кто столкнулся с этим примером впервые.

Все мы знаем, что статический конструктор вызывается перед доступом к любому члену класса (за исключением констант). При этом запускается он единственный раз в рамках application domain.

В нашем случае мы обращаемся к члену класса — свойству Instance, что должно вызвать сначала запуск статического конструктора, а потом вызовет конструктор экземпляра класса. Т.е. программа выведет:

Static Logger Constructor
Instance Logger Constructor

Однако после запуска программы мы получим на консоли:

Instance Logger Constructor
Static Logger Constructor

Как так? Инстанс конструктор отработал раньше статического конструктора?!?
Ответ: Да!

И вот почему.

В стандарте ECMA-334 языка C# на счет статических классов указано следующее:

17.4.5.1: «If a static constructor (§17.11) exists in the class, execution of the static field initializers occurs immediately prior to executing that static constructor.
…
17.11: … If a class contains any static fields with initializers, those initializers are executed in textual order immediately prior to executing the static constructor

(Что в вольном переводе значит: если в классе есть статический конструктор, то запуск инициализации статических полей происходит непосредственно ПЕРЕД запуском статического конструктора.
…
Если класс содержит какие-либо статические поля с инициализаторами, то такие инициализаторы запускаются в порядке следования в тексте программы непосредственно ПЕРЕД запуском статического конструктора.)

В нашем случае статическое поле innerInstance объявлено вместе с инициализатором, в качестве которого выступает конструктор экземпляра класса. Согласно стандарту ECMA инициализатор должен быть вызван ПЕРЕД вызовом статического конструктора. Что и происходит в нашей программе: конструктор экземпляра, являясь инициализатором статического поля, вызывается ДО статического конструктора. Согласитесь, довольно неожиданно.

Обратим внимание, что это верно только для инициализаторов статических полей. В общем случае статический конструктор вызывается ПЕРЕД вызовом конструктора экземпляра класса.

Как, например, тут:

class MyLogger
{
    static MyLogger()
    {
        Console.WriteLine("Static Logger Constructor");
    }

    public MyLogger()
    {
        Console.WriteLine("Instance Logger Constructor");
    }
}

class Program
{
    public static void Main()
    {
        var logger = new MyLogger();
    }
}

И программа ожидаемо выведет на консоль:

Static Logger Constructor
Instance Logger Constructor

-5 нечетное число, но в качестве ответа нашей функции мы получим False!
Разберемся, в чем причина.

Согласно MSDN про оператор остатка от деления % написано следующее:
«Для целочисленных операндов результатом a % b является значение, произведенное a — (a / b) * b»
В нашем случае для a=-5, b=2 мы получаем:
-5 % 2 = (-5) — ((-5) / 2) * 2 = -5 + 4 = -1
Но -1 всегда не равно 1, что объясняет наш результат False.

Оператор % чувствителен к знаку операндов. Поэтому, чтобы не получать таких «сюрпризов», лучше результат сравнивать с нулем, у которого нет знака:

static bool isOddNumber(int i)
{
    return (i % 2 != 0);
}

Или завести отдельную функцию проверки на четность и реализовать логику через нее:

static bool isEvenNumber(int i)
{
    return (i % 2 == 0);
}

static bool isOddNumber(int i)
{
    return !isEvenNumber(i);
}

Мы получим на экране значение переменной summResult, которое равно начальному значению, т.е. 0.

Почему так произошло?

А потому, что определение LINQ запроса и запуск этого запроса – это две операции, которые выполняются отдельно. Таким образом, определение запроса еще не означает его запуск/выполнение.

Переменная summResult используется внутри анонимного делегата в методе Select: последовательно перебираются элементы массива dataArray и прибавляются к переменной summResult.

Можно предположить, что наш код напечатает сумму элементов массива dataArray. Но LINQ работает не так.

Рассмотрим переменную selectedData. Ключевое слово var – это «синтаксический сахар», который во многих случаях сокращает размер кода программы и улучшает ее читабельность. А настоящий тип переменной selectedData реализует интерфейс IEnumerable. Т.е. наш код выглядит так:

    IEnumerable<int> selectedData = dataArray.Select(
    x =>
    {
        summResult += x;
        return x;
    }); 

Здесь мы определяем запрос (Query), но сам запрос не запускаем. Схожим образом можно работать с базой данных, задавая SQL запрос в виде строки, но для получения результата обращаясь к базе данных и запуская этот запрос в явном виде.

То есть пока мы только задали запрос, но не запустили его. Вот почему значение переменной summResult осталось без изменений. А запустить запрос можно, например, с помощью методов ToArray, ToList или ToDictionary:

int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 };

int summResult = 0;

// определяем запрос и сохраняем его в переменной selectedData
IEnumerable<int> selectedData = dataArray.Select(
    x =>
    {
        summResult += x;
        return x;
    });

// запускаем запрос selectedData
selectedData.ToArray();

// печатаем значение переменной summResult
Console.WriteLine(summResult);

Этот код уже выведет на экран значение переменной summResult, равное сумме всех элементов массива dataArray, равное 15.

С этим разобрались. А что тогда выведет на экран эта программа?

int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 }; //1
var summResult = dataArray.Sum() + dataArray.Skip(3).Take(2).Sum(); //2
var groupedData = dataArray.GroupBy(x => x).Select(  //3
    x =>
    {
        summResult += x.Key;
        return x.Key;
    });

Console.WriteLine(summResult); //4

Переменная groupedData (строка 3) на самом деле реализует интерфейс IEnumerable и по сути определяет запрос к источнику данных dataArray. А это значит, что для работы анонимного делегата, который изменяет значение переменной summResult, этот запрос должен быть запущен явно. Но такого запуска в нашей программе нет. Поэтому значение переменной summResult будет изменено только в строке 2, а все остальное мы можем не рассматривать в наших вычислениях.

Тогда нетрудно посчитать значение переменной summResult, которое равно, соответственно, 15 + 7, т.е. 22.

Ответ: 1

Можно подумать, что здесь используется численная арифметика над размерами каждого типа в байтах, поскольку для преобразования типов тут довольно неожиданно встречаются знаки «+» и «-».

Известно, что в C# тип integer имеет размер 4 байта, long – 8, char – 2.

Тогда легко подумать, что наша строка кода будет равносильна следующему арифметическому выражению:

int i = (4)+(2)-(4)+(8)-1;

Однако это не так. А чтобы сбить с толку и направить по такому ложному рассуждению, пример может быть изменен, например, так:

int i = (int)+(char)-(int)+(long)-sizeof(int);

Знаки «+» и «-» используются в этом примере не как бинарные арифметические операции, а как унарные операторы. Тогда наша строка кода является лишь последовательностью явных преобразований типов, перемешанных с вызовами унарных операций, которую можно записать так:

        int i =
        (int)( // call explicit operator int(char), i.e. char to int
          +( // call unary operator +
            (char)( // call explicit operator char(int), i.e. int to char
              -( // call unary operator -
                (int)( // call explicit operator int(long), i.e. long to int
                  +( // call unary operator +
                    (long)( // call explicit operator long(int), i.e. int to long
                      -1
                    )
                  )
                )
              )
            )
          )
        );