Подробно знание IL, важного для разработки .NET

Если вы просто пытаетесь написать приложение .NET, вам не нужны практические знания кода IL. Большинство разработчиков .NET не умеют писать в коде IL.

IL поможет вам, если вы пытаетесь понять, что на самом деле происходит. Вы можете использовать его для написания более эффективного кода на машине, что может быть неочевидно на языке .NET, который вы пишете.

Вы можете использовать следующее:

validates_uniqueness_of :name, :case_sensitive => false

Обратите внимание, что по умолчанию настройка is:case_sensitive = > false, поэтому вам даже не нужно писать этот параметр, если вы не изменили другие способы.

Дополнительную информацию можно найти по адресу: http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#method-i-validates_uniqueness_of

Лично я думаю, что это недостаток в дизайне Java. Да, да, я понимаю, что нестатические методы присоединены к экземпляру, а статические методы присоединены к классу и т.д. Однако рассмотрим следующий код:

public class RegularEmployee {
    private BigDecimal salary;

    public void setSalary(BigDecimal salary) {
        this.salary = salary;
    }

    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".02");
    }

    public BigDecimal calculateBonus() {
        return salary.multiply(getBonusMultiplier());
    }

    /* ... presumably lots of other code ... */
}

public class SpecialEmployee extends RegularEmployee {
    public static BigDecimal getBonusMultiplier() {
        return new BigDecimal(".03");
    }
}

Этот код не будет работать так, как можно было бы ожидать. А именно, SpecityEmployee получает бонус в 2% так же, как и обычные сотрудники. Но если удалить «статические», то SpecureEmployee получит бонус 3%.

(Надо признать, что этот пример является плохим стилем кодирования в том, что в реальной жизни вы, вероятно, хотели бы, чтобы бонусный множитель находился в базе данных где-то, а не жестко закодирован. Но это просто потому, что я не хотел свернуть пример с большим количеством кода, не имеющего отношения к точке.)

Мне кажется вполне правдоподобным, что вы можете сделать getPortingMultiplier статичным. Возможно, необходимо иметь возможность просмотра множителя бонуса для всех категорий сотрудников без необходимости иметь экземпляр сотрудника в каждой категории. Какова будет точкой поиска таких примеров? Что делать, если создается новая категория сотрудников, которой еще не присвоены сотрудники? Это вполне логично статическая функция.

Но это не работает.

И да, да, я могу придумать любое количество способов переписать вышеуказанный код, чтобы он работал. Мой пункт не в том, что это создает неразрешимую проблему, а в том, что это создает ловушку для нецензурного программиста, потому что язык ведет себя не так, как я думаю, разумный человек ожидал бы.

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

Или, возможно, есть какая-то веская причина, почему Java ведет себя так. Может ли кто-нибудь указать на преимущество такого поведения, какой-то категории проблем, которая облегчается этим? Я имею в виду, не просто указать мне на язык Java и сказать «смотрите, это документировано, как он ведет себя». Я знаю это. Но есть ли веская причина, почему он ДОЛЖЕН вести себя так путь?

Обновление

@ VicKirk: Если вы имеете в виду, что это «плохой дизайн», потому что он не подходит для того, как Java обрабатывает статику, мой ответ: «Ну, duh, конечно.» Как я сказал в своем первоначальном посте, это не работает. Но если вы имеете в виду, что плохой дизайн в том смысле, что было бы что-то принципиально неправильное с языком, где это работало, т.е. где статика могла бы быть переопределена так же, как виртуальные функции, что это как-то ввело бы двусмысленность или было бы невозможно эффективно реализовать или какой-то такой, я отвечаю: "Почему? Что не так с концепцией?"

Я думаю, что пример, который я приведу, это очень естественная вещь, которую я хочу сделать. У меня есть класс, который имеет функцию, которая не зависит от каких-либо данных экземпляра, и который я мог бы разумно захотеть вызвать независимо от экземпляра, а также желая вызвать из внутри метода экземпляра. Почему это не должно сработать? Я сталкивался с этой ситуацией довольно много раз за эти годы. На практике я обходю его, делая функцию виртуальной, а затем создавая статический метод, единственной целью которого в жизни является статический метод, который передает вызов виртуальному методу с фиктивным экземпляром. Это кажется очень круговым способом добраться туда.

Помимо очевидного (реализация виртуальной машины), некоторые типы задач требовали довольно глубокого понимания IL.

• Запись динамического кода. Это было довольно хорошо заменено API System.Linq.Expressions, особенно учитывая его способности в .NET 4.
• Создание компилятора для нового языка, предназначенного для интерфейса командной строки. Такие проекты, как Common Compiler Infrastructure , направлены на уменьшение количества фактических записей, которые должны записывать составители кода CIL.

Один из самых интересных аспектов для меня лично - изучение влияния языка IL на компилятор только что. Один примечательный пример, контрастирующий с JVM и CLI, состоит в том, что CLI имеет понятие невиртуальных методов и прямой рассылки, что позволяет особенно эффективным вызовам излучаться неоптимизирующим (базовым) компилятором. Этот анализ является более дорогостоящим в JVM, поэтому компилятор базовой линии не может оптимизировать столько случаев.

В ответ на первоначальный вопрос:

В целом разработчикам .NET не нужно беспокоиться об изучении CIL. Если работа включает в себя выполнение/динамически генерируемые методы, то следует оценить способность API Expressions удовлетворять ваши потребности, так как он чрезвычайно более пригоден для использования/обслуживания. Я провел несколько недель, выделяя CIL с ILGenerator. Мне понадобилось одно время, чтобы преобразовать в Выражения, сохранив более сотни строк кода и исправив старые ошибки, которые я просто не понял.

Подробное знание CIL очень важно для всех, кто реализует виртуальную машину CLI или пишущих компиляторов (AOT или JIT). Я нахожу это как интересным, так и полезным, но в области "важных вещей, чтобы знать, чтобы быть продуктивным разработчиком", это просто не так высоко.

На самом деле есть только одно место в платформе .NET, где у вас есть , чтобы знать IL, классы в System.Reflection.Emit пространство имен. Он позволяет генерировать код «на лету», который может быть полезен в некоторых случаях.

Лучший способ познакомиться с ИЛ - это илдазм.exe, Reflector тоже может работать. Очень удобный способ запустить его - добавить в меню «Инструменты». Инструменты + Внешние инструменты, Доп.

• Заголовок = Ildasm
• Команда = c: \ Program Files \ Microsoft SDK \ Windows \ v6.0A \ Bin \ ildasm.exe
• Аргументы = $ (TargetPath)
• Начальный каталог = $ (TargetDir)

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

Следующий шаг - взглянуть на то, как IL переводится в машинный код. Запустите отладку, щелкните код правой кнопкой мыши и выберите «Перейти к разборке». Помните, что вы не будете смотреть на реальный машинный код, если не запустите сборку Release и не включите оптимизацию JIT. Инструменты + Параметры, Отладка, снимите галочку «Подавлять JIT-оптимизацию при загрузке модуля».

Зависит. Знание IL, вероятно, поможет вам понять, во что превращается ваш код. Если вы хорошо разбираетесь в IL, вы даже можете создавать новые компоненты во время выполнения (если вам нужно). Это важно? Возможно нет.

Знание сборки очень хорошо подходит для C / C ++ в Visual Studio. Вы всегда можете пойти на разборку, чтобы посмотреть, что происходит.

Если вы попробуете сделать то же самое в C #, то есть «Перейти к дизассемблированию», вы все равно перейдете к машинному коду, а не к IL. В этом смысле IL не так полезен, как настоящая сборка.

Но IL хорош для просмотра тех сборок, у которых также нет исходного кода. (Но для этого можно использовать отражатель )

Нет, как большинство сказали. Кроме того, чтобы добавить к их комментариям, посмотрите, почему вы используете C / C ++ и почему вы используете .NET и его языки (liek C #):

C / C ++ был создан, чтобы дать вам власть над компьютером в хороший абстрактный способ. Он почти преобразован непосредственно в язык ассемблера и дает вам огромную силу для добра (и зла). Такие вещи, как указатели, приветствуются, и сборка мусора отсутствует. Следовательно, вы должны знать, что делает код языка ассемблера из-за того, что вы можете делать.

Языки .NET созданы для быстрого создания отличных приложений и ограничения ущерба, который вы можете нанести этим приложениям. Это мешает вам использовать реальную власть над процессором (например, указатели не рекомендуются, и вам не нужно беспокоиться о сборке мусора по большей части). В основном, ущерб, который вы можете нанести, ограничивается приложением; и мало общего с процессором (если вы не балуетесь небезопасным кодом, который используется только в редких случаях [по моему опыту]). Кроме того, код .NET преобразуется в IL, затем IL преобразуется в сборку и так далее ... в любом случае вы напрямую не имеете дело с языком ассемблера.

Они сказали, что хорошо знать ИЛ, чтобы научиться разбираться в голове, и это может вам немного помочь. Но знание этого не очень поможет вам создать отличное приложение - в этом заключается смысл языков .NET для большинства разработчиков, не работающих в Microsoft.