Unity windows build support il2cpp что это

The IL2CPP (Intermediate Language To C++) scripting backendA framework that powers scripting in Unity. Unity supports three different scripting backends depending on target platform: Mono, .NET and IL2CPP. Universal Windows Platform, however, supports only two: .NET and IL2CPP. More info
See in Glossary is an alternative to the Mono backend. IL2CPP provides better support for applications across a wider range of platforms. The IL2CPP backend converts MSIL (Microsoft Intermediate Language) code (for example, C# code in scripts) into C++ code, then uses the C++ code to create a native binary file (for example, .exe, .apk, or .xap) for your chosen platform.

This type of compilation, in which Unity compiles code specifically for a target platform when it builds the native binary, is called ahead-of-time (AOT) compilation. The Mono backend compiles code at runtime, with a technique called just-in-time compilation (JIT).

On this page:

• Building a project using IL2CPP
• How IL2CPP works
• Optimising IL2CPP build times
• Enabling runtime checks using IL2CppSetOption

Some platforms don’t support AOT compilationAhead of Time (AOT) compilation is an optimization method used by all platforms except iOS for optimizing the size of the built player. . More info
See in Glossary, so the IL2CPP backend doesn’t work on every platform. Other platforms support AOT and IL2CPP, but don’t allow JIT compilation, and so can’t support the Mono backend. When a platform can support both backends, Mono is the default. For more information, see Scripting restrictions.

IL2CPP can improve performance across a variety of platforms, but the need to include machine code in built applications increases both the build time and the size of the final built application. For more information, see How IL2CPP works and the blog series An introduction to IL2CPP internals.

IL2CPP supports the debugging of managed code in the same way as the Mono scripting backend. For more information, see Debugging C# code in Unity.

Building a project using IL2CPP

To build a project with IL2CPP, you need to have the backend installed in your Unity installation. You can select IL2CPP as an optional module when you first install a version of Unity, or add IL2CPP support to an existing installation through the Unity Hub. For more information, see Installing the Unity Hub and Add modules to the Unity Editor.

IL2CPP also requires some systems native to the target platform to generate the C++ code. This means that to use IL2CPP on a specific platform, you need to build the application on that platform. For example, to use IL2CPP with MacOS as a build target, you need to build the application on a machine that uses MacOS. For more information about system requirements for desktop platforms, including IL2CPP requirements for individual platforms, see the Desktop section of System Requirements for Unity.

You can change the scripting backend Unity uses to build your application in one of two ways:

• Through the Player SettingsSettings that let you set various player-specific options for the final game built by Unity. More info
  See in Glossary menu in the Editor. Perform the following steps to change the scripting backend through the Player Settings menu:

  1. Go to Edit > Project Settings.
  2. Click on the Player Settings button to open the Player settings for the current platform in the Inspector.
  3. Navigate to the Configuration section heading under the Other Settings sub-menu.
  4. Click on the Scripting Backend dropdown menu, then select IL2CPP.

  You can also open the Player Settings menu from inside the Build Settings menu; go to File > Build Settings and click on the Player Settings button.

• Through the Editor scripting API. Use the PlayerSettings.SetScriptingBackend property to change the scripting backend that Unity uses.

Картинка с сайта: docs.unity3d.com

To start the build process, open the Build Settings window and click the Build button. Unity then converts your C# code and assemblies into C++ and finally produces a binary file for your target platform.

How IL2CPP works

When you start a build using IL2CPP, Unity automatically performs the following steps:

1. The Roslyn C# compiler compiles your application’s C# code and any required package code to .NET DLLs (managed assemblies).
2. Unity applies managed bytecode stripping. This step can significantly reduce the size of a built application.
3. The IL2CPP backend converts all managed assemblies into standard C++ code.
4. The C++ compiler compiles the generated C++ code and the runtime part of IL2CPP with a native platform compiler.
5. Unity creates either an executable file or a DLL, depending on the platform you target.

Both IL2CPP and Mono provide a few useful options which you can control with attributes in your scriptsA piece of code that allows you to create your own Components, trigger game events, modify Component properties over time and respond to user input in any way you like. More info
See in Glossary. For more information, see Platform-dependent compilation.

IL2CPP enables Unity to pre-compile code for specific platforms. The binary file Unity produces at the end of this process already contains necessary machine code for the target platform, while Mono has to compile this machine code at runtime during execution. AOT compilation does increase build time, but it also improves compatibility with the target platform and can improve performance.

Both scripting backends require a new build for each platform you want to target. For example, to support both the Android and iOS platforms, you need to build your application twice and produce two binary files.

The assembly stripping stage helps reduce the final binary size. Unity removes any bytecode that the final built application doesn’t use.

Optimizing IL2CPP build times

Project build times when using IL2CPP can be significantly longer than when using Mono. However, you can do several things to reduce build time.

Exclude your project from anti-malware software scans

You can exclude your Unity project folder and target build folders from anti-malware software scans before you build your project.

Store your project and target build folder on a solid-state drive (SSD)

Solid-state drives (SSDs) have faster read/write speeds than traditional hard disk drives (HDD). Converting IL code to C++ and compiling it involves a large number of read/write operations, so a faster storage device speeds up this process.

Change the IL2CPP Code Generation option in the Build Settings

To change how IL2CPP generates code, open the Build Settings and configure the IL2CPP Code Generation option By default, the Faster runtime option is enabled, which produces more machine code that reduces the impact of IL2CPP at runtime. To reduce build times, you can set this option to Faster (smaller) builds. This method produces and includes less machine code in the binary executable and so can reduce performance at runtime, but also significantly reduces build times and binary size.

Enabling runtime checks using Il2CppSetOption

When you use the IL2CPP scripting backend, you can control how il2cpp.exe generates C++ code. You can use the Il2CppSetOption attribute to enable or disable the following runtime checks:

To use the Il2CppSetOption attribute:

1. In the directory where your Unity version is installed, navigate to the Data\il2cpp directory on Windows, or the Contents/Frameworks/il2cpp directory on OS X.
2. Find the Il2CppSetOptionAttribute.cs source file.
3. Copy the source file into your project’s Assets directory.

The below example describes how to use the Il2CppSetOption attribute:

[Il2CppSetOption(Option.NullChecks, false)]
public static string MethodWithNullChecksDisabled()
{
    var tmp = new object();
    return tmp.ToString();
}

You can apply Il2CppSetOption attribute to types, methods, and properties. Unity uses the attribute from the most local scope.

[Il2CppSetOption(Option.NullChecks, false)]
public class TypeWithNullChecksDisabled
{
    public static string AnyMethod()
    {
        // Unity doesn’t perform null checks in this method.
        var tmp = new object();
        return tmp.ToString();
    }

    [Il2CppSetOption(Option.NullChecks, true)]
    public static string MethodWithNullChecksEnabled()
    {
        // Unity performs null checks in this method.
        var tmp = new object();
        return tmp.ToString();
    }
}

public class SomeType
{
    [Il2CppSetOption(Option.NullChecks, false)]
    public string PropertyWithNullChecksDisabled
    {
        get
        {
            // Unity doesn’t perform null checks here.
            var tmp = new object();
            return tmp.ToString();
        }
        set
        {
            // Unity doesn’t perform null checks here.
            value.ToString();
        }
    }

    public string PropertyWithNullChecksDisabledOnGetterOnly
    {
        [Il2CppSetOption(Option.NullChecks, false)]
        get
        {
            // Unity doesn’t perform null checks here.
            var tmp = new object();
            return tmp.ToString();
        }
        set
        {
            // Unity performs null checks here.
            value.ToString();
        }
    }
}

• 2018–05–15 Page amended

Время на прочтение6 мин

Количество просмотров47K

Unity продолжают совершенствовать технологию IL2CPP, а мы публикуем перевод статьи о том, как она работает.

Картинка с сайта: habr.com

Около года назад мы писали о будущем скриптинга в Unity. Новая технология скриптинга IL2CPP должна была обеспечить движок высокопроизводительной портативной виртуальной машиной. В январе мы выпустили нашу первую платформу на 64-битной iOS, использующую IL2CPP. С выходом Unity 5 появилась еще одна платформа – WebGL. При поддержке огромного сообщества пользователей мы выпустили множество патчей и обновлений для IL2CPP, постепенно оптимизируя компилятор и повышая быстродействие среды.

А пока мы продолжаем совершенствовать технологию IL2CPP, было бы неплохо рассказать о том, как она работает. Мы планируем написать серию статей, посвященных таким темам:

1. Основы – набор инструментов и аргументы командной строки (эта статья).
2. Экскурсия по генерируемому коду.
3. Советы по отладке генерируемого кода.
4. Вызовы методов: обычные методы, виртуальные методы и другие.
5. Реализация общего обмена.
6. Обёртки P/Invoke для типов и методов.
7. Интеграция сборщика мусора.
8. Тестирование и применение фреймворков.

В этих статьях мы обсудим некоторые особенности реализации IL2CPP. Надеюсь, эта информация вам пригодится.

Что такое IL2CPP?

Технология IL2CPP состоит из двух частей:

• компилятор Ahead-of-time (AOT);
• исполняемая библиотека для поддержки виртуальной машины.

AOT-компилятор переводит промежуточный язык (IL) из .NET-компиляторов в исходный код C++. Исполняемая библиотека предоставляет сервисы и абстракции (такие как сборщик мусора), межплатформенный доступ к потокам и файлам, а также способы реализации внутренних вызовов (неуправляемый код, напрямую изменяющий управляемые структуры данных).

AOT-компилятор

AOT-компилятор IL2CPP называется il2cpp.exe. В Windows его можно найти в директории Editor\Data\il2cpp, а в OS X – в директории Contents/Frameworks/il2cpp/build в месте установки Unity. Утилита il2cpp.exe полностью написана на языке C# и скомпилирована с помощью .NET и компиляторов Mono.

Эта утилита принимает управляемые сборки, скомпилированные Mono-компилятором, поставляемым с Unity, и генерирует код C++, который мы передаем в компилятор C++ для конкретной платформы.
Инструментарий IL2CPP можно схематически представить так:

Картинка с сайта: habr.com

Исполняемая библиотека

Вторая часть технологии IL2CPP – это исполняемая библиотека для поддержки виртуальной машины. Мы написали эту библиотеку почти полностью на C++ (в ней есть немного платформенного кода, но пусть это останется между нами) и назвали ее libil2cpp. Она поставляется в виде статической библиотеки, связанной с исполняемым файлом плеера, а ее простота и портативность являются одними из ключевых преимуществ технологии IL2CPP.

Вы можете получить более четкое представление об организации кода libil2cpp, глядя на файлы заголовков, поставляемых с Unity (их можно найти в директории Editor\Data\PlaybackEngines\webglsupport\BuildTools\Libraries\libil2cpp\include в Windows, или в директории Contents/Frameworks/il2cpp/libil2cpp – в OS X). Например, интерфейс между кодом C++, генерируемым il2cpp.exe, и средой libil2cpp находится в файле заголовка codegen/il2cpp-codegen.h.

Один из ключевых элементов среды – сборщик мусора. В комплект Unity 5 входит libgc, сборщик мусора Boehm-Demers-Weiser. Однако libil2cpp поддерживает и другие сборщики. Например, мы рассматриваем возможность интеграции с Microsoft GC – сборщиком с открытым исходным кодом в комплекте CoreCLR. В одной из следующих статей мы расскажем о нём подробнее.

Как выполняется il2cpp.exe?

Давайте рассмотрим на примере. Для этого я создам новый пустой проект в Unity 5.0.1 на Windows. Чтобы у нас был хотя бы один пользовательский скрипт, я добавлю к главной камере простой компонент MonoBehaviour:

Картинка с сайта: habr.com

При сборке для платформы WebGL я могу использовать Process Explorer, чтобы увидеть команду для запуска il2cpp.exe:

"C:\Program Files\Unity\Editor\Data\MonoBleedingEdge\bin\mono.exe" "C:\Program Files\Unity\Editor\Data\il2cpp/il2cpp.exe" --copy-level=None --enable-generic-sharing --enable-unity-event-support --output-format=Compact --extra-types.file="C:\Program Files\Unity\Editor\Data\il2cpp\il2cpp_default_extra_types.txt" "C:\Users\Josh Peterson\Documents\IL2CPP Blog Example\Temp\StagingArea\Data\Managed\Assembly-CSharp.dll" "C:\Users\Josh Peterson\Documents\IL2CPP Blog Example\Temp\StagingArea\Data\Managed\UnityEngine.UI.dll" "C:\Users\Josh Peterson\Documents\IL2CPP Blog Example\Temp\StagingArea\Data\il2cppOutput"


Это достаточно длинная строка, поэтому давайте разберем ее по частям. Сперва Unity запускает этот исполняемый файл:

«C:\Program Files\Unity\Editor\Data\MonoBleedingEdge\bin\mono.exe»

Следующий аргумент – сама утилита il2cpp.exe.

«C:\Program Files\Unity\Editor\Data\il2cpp/il2cpp.exe»

Остальные аргументы передаются il2cpp.exe, а не mono.exe. Давайте разберем и их. Во-первых, Unity передает 5 флагов il2cpp.exe:

• -copy-level=None
Указывает, что il2cpp.exe не следует выполнять специальные копии файлов генерируемого кода C++.

• -enable-generic-sharing
Уменьшает размер кода и бинарного файла. Со временем мы опубликуем процесс выполнения универсальных методов в IL2CPP.

• -enable-unity-event-support
Обеспечивает корректную генерацию кода для событий Unity, вызываемых при помощи рефлексии.

• -output-format=Compact
Генерирует код C++ в формате с меньшим количеством символов для имен типов и методов. Учитывая, что имена на промежуточном языке не сохраняются, такой код сложнее отлаживать, но зато он быстрее компилируется, поскольку компилятору C++ нужно разобрать меньше кода.

• -extra-types.file=»C:\Program Files\Unity\Editor\Data\il2cpp\il2cpp_default_extra_types.txt»
Использует стандартный пустой файл для дополнительных типов. Его можно добавить в проект Unity, чтобы il2cpp.exe знал, какие универсальные или индексируемые типы создаются во время выполнения, но не указаны в коде IL.

Стоит отметить, что этот набор аргументов командной строки для il2cpp.exe всё еще нестабилен и, скорее всего, изменится в последующих версиях.

Итак, в командной строке указаны 2 файла и 1 директория:

• «C:\Users\Josh Peterson\Documents\IL2CPP Blog Example\Temp\StagingArea\Data\Managed\Assembly-CSharp.dll»
• «C:\Users\Josh Peterson\Documents\IL2CPP Blog Example\Temp\StagingArea\Data\Managed\UnityEngine.UI.dll»
• «C:\Users\Josh Peterson\Documents\IL2CPP Blog Example\Temp\StagingArea\Data\il2cppOutput»

Утилита il2cpp.exe принимает список всех сборок IL, подлежащих конвертации. В нашем случае сюда входит мой простой скрипт MonoBehaviour, Assembly-CSharp.dll и UnityEngine.UI.dll. Обратите внимание, что здесь явно отсутствует несколько сборок. Очевидно, что мой скрипт ссылается на UnityEngine.dll, а значит нужен хотя бы mscorlib.dll, и, возможно, другие сборки. Но где они? Дело в том, что разрешение сборок происходит внутри il2cpp.exe. Их можно упомянуть в командной строке, но это необязательно. Получается, Unity нужно всего лишь указать корневые сборки (на которые не ссылаются другие сборки).

Последний аргумент командной строки il2cpp.exe – каталог, в котором создаются файлы C++. Если вам интересно, вы можете сами ознакомиться со сгенерированными файлами, но мы еще поговорим о них подробнее в следующей статье. Прежде чем открыть каталог, вам стоит выбрать опцию Development Player в настройках сборки WebGL. Это удалит аргумент -output-format=Compact и улучшит отображение имен типов и методов в коде C++.

Попробуйте поиграть с настройками Player Settings WebGL или iOS. Вы увидите различные параметры командной строки, передаваемые il2cpp.exe и отвечающие за различные этапы генерации кода. Например, задав параметру Enable Exceptions в WebGL Player Settings значение Full, вы добавите в командную строку аргументы -emit-null-checks, -enable-stacktrace и -enable-array-bounds-check.

Чего не делает IL2CPP?

Хотелось бы обратить внимание на одну сложность, которую мы решили обойти стороной и таким образом избежали многих проблем. Мы не пытались переписать стандартную библиотеку C# под IL2CPP. При создании проекта Unity с использованием IL2CPP весь код стандартных библиотек C# (mscorlib.dll, System.dll и т. д.) является точной копией кода Mono-скриптов.

Мы используем код стандартных библиотек C#, потому что он уже успел хорошо зарекомендовать себя во многих проектах. Таким образом, если где-то возникает ошибка, мы можем быть уверены, что проблема в AOT-компиляторе или исполняемой библиотеке.

Разработка, тестирование и выпуск IL2CPP

С момента первого официального релиза IL2CPP версии 4.6.1p5 в январе мы выпустили 6 полноценных обновлений и 7 патчей (для Unity 4.6 и 5.0), в которых исправили более ста ошибок.

Чтобы обеспечить непрерывную оптимизацию, мы разрабатываем обновления на базе одной версии кода. Перед каждым релизом мы передаем все изменения в конкретную релизную ветку, проводим тестирование и проверяем, все ли ошибки были успешно исправлены. Наши команды QA и Sustained Engineering прикладывают максимум усилий, чтобы разработка велась в таком темпе, и ошибки исправлялись каждую неделю.

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

Для разработчиков IL2CPP тестирование стоит на первом месте. Мы часто берем за основу технику разработки через тестирование и крайне редко отправляем запросы на включение, если код не был полностью протестирован. Эта стратегия хорошо работает для таких технологий, как IL2CPP, где есть четкие входы и выходы. Это означает, что подавляющее большинство ошибок, с которыми мы сталкиваемся, являются скорее частными случаями, чем неожиданным поведением системы (например, при использовании 64-битного IntPtr в качестве 32-битного индекса массива может произойти вылет с ошибкой компилятора С++). Таким образом, мы можем быстро определять и исправлять любые баги.
При поддержке нашего сообщества мы всё время делаем IL2CPP стабильнее и производительнее.

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

IL2CPP (промежуточный язык для C++) серверная часть сценариев Фреймворк, поддерживающий сценарии в Unity. Unity поддерживает три различных бэкэнда для сценариев в зависимости от целевой платформы: Mono, .NET и IL2CPP. Однако универсальная платформа Windows поддерживает только два: .NET и IL2CPP. Дополнительная информация
См. в Словарь – это альтернатива серверной части Mono. IL2CPP обеспечивает лучшую поддержку приложений на более широком диапазоне платформ. Серверная часть IL2CPP преобразует код MSIL (Microsoft Intermediate Language) (например, код C# в сценариях) в код C++, а затем использует код C++ для создания собственного двоичного файла (например, .exe, .apk или .xap) для выбранная вами платформа.

Этот тип компиляции, при котором Unity компилирует код специально для целевой платформы при создании собственного двоичного файла, называется компиляцией с опережением (AOT). Бэкенд Mono компилирует код во время выполнения с помощью техники, называемой JIT-компиляцией.

На этой странице:

• Создание проекта с использованием IL2CPP
• Как работает IL2CPP
• Оптимизация времени сборки IL2CPP
• Включение проверок во время выполнения с помощью IL2CppSetOption

Некоторые платформы не поддерживают компиляцию AOTКомпиляция с опережением времени (AOT) — это метод оптимизации iOS для оптимизации размера встроенного проигрывателя iOS Подробнее
См. в Словарь, так что бэкенд IL2CPP работает не на каждой платформе. Другие платформы поддерживают AOT и IL2CPP, но не допускают JIT-компиляции и поэтому не могут поддерживать бэкэнд Mono. Когда платформа может поддерживать оба бэкенда, по умолчанию используется Mono. Дополнительную информацию см. в разделе Ограничения использования сценариев.

IL2CPP может повысить производительность на различных платформах, но необходимость включения машинного кода во встроенные приложения увеличивает как время сборки, так и размер конечного приложения. Дополнительную информацию см. в разделе Как работает IL2CPP и в серии блогов Введение во внутренние устройства IL2CPP. .

IL2CPP поддерживает отладку управляемого кода так же, как и серверная часть сценариев Mono. Дополнительную информацию см. в разделе Отладка кода C# в Unity.

Сборка проекта с использованием IL2CPP

Чтобы создать проект с помощью IL2CPP, вам необходимо установить серверную часть в вашей установке Unity. Вы можете выбрать IL2CPP в качестве дополнительного модуля при первой установке версии Unity или добавить поддержку IL2CPP в существующую установку через Unity Hub. Дополнительные сведения см. в разделах Установка Unity Hub и Добавить модули в редактор Unity.

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

• Через Настройки игрокаНастройки, которые позволяют вам установить различные параметры для конкретного игрока для окончательной игры, созданной Unity. . Подробнее
  См. в меню Словарь в Редакторе. Выполните следующие шаги, чтобы изменить серверную часть сценариев через меню Настройки проигрывателя:

  1. Выберите Редактировать > Настройки проекта.
  2. Нажмите кнопку Настройки проигрывателя, чтобы открыть настройки проигрывателя для текущей платформы в Инспектор.
  3. Перейдите к заголовку раздела Конфигурация в подменю Другие настройки.
  4. Нажмите раскрывающееся меню Scripting Backend, затем выберите IL2CPP.

  Вы также можете открыть меню Настройки проигрывателя из меню Настройки сборки; перейдите в раздел Файл > Настройки сборки и нажмите кнопку Настройки проигрывателя.

• Через API сценариев редактора. Используйте свойство PlayerSettings.SetScriptingBackend, чтобы изменить серверную часть сценариев, которую использует Unity.

Картинка с сайта: unityhub.ru

Как работает IL2CPP

Когда вы запускаете сборку с использованием IL2CPP, Unity автоматически выполняет следующие шаги:

1. Компилятор Roslyn C# компилирует код C# вашего приложения и любой необходимый код пакета в .NET DLL (управляемые сборки).
2. Unity применяет управляемое удаление байт-кода. Этот шаг может значительно уменьшить размер встроенного приложения.
3. Бэкенд IL2CPP преобразует все управляемые сборки в стандартный код C++.
4. Компилятор C++ компилирует сгенерированный код C++ и исполняемую часть IL2CPP с помощью собственного компилятора платформы.
5. Unity создает либо исполняемый файл, либо DLL, в зависимости от целевой платформы.

Как IL2CPP, так и Mono предоставляют несколько полезных параметров, которыми можно управлять с помощью атрибутов в ваших скриптахфрагмент кода, который позволяет вы можете создавать свои собственные Компоненты, запускать игровые события, изменять свойства Компонентов с течением времени и реагировать на ввод данных пользователем любым удобным для вас способом. Подробнее
См. в Словарь. Дополнительные сведения см. в разделе Компиляция в зависимости от платформы.

IL2CPP позволяет Unity предварительно компилировать код для определенных платформ. Двоичный файл, который Unity создает в конце этого процесса, уже содержит необходимый машинный код для целевой платформы, в то время как Mono должен компилировать этот машинный код во время выполнения во время выполнения. Компиляция AOT увеличивает время сборки, но также улучшает совместимость с целевой платформой и может повысить производительность.

Для обоих бэкэндов сценариев требуется новая сборка для каждой целевой платформы. Например, для поддержки как Android, так и iOSмобильной операционной системы Apple. Подробнее
На платформах Словарь вам нужно дважды собрать приложение и создать два двоичных файла. файлы.

Этап разборки сборки помогает уменьшить окончательный размер двоичного файла. Unity удаляет любой байт-код, который не используется в готовом приложении.

Оптимизация времени сборки IL2CPP

Время сборки проекта при использовании IL2CPP может быть значительно больше, чем при использовании Mono. Однако вы можете сделать несколько вещей, чтобы сократить время сборки.

Исключить ваш проект из сканирования антивирусным ПО

Вы можете исключить папку проекта Unity и целевые папки сборки из сканирования программным обеспечением для защиты от вредоносных программ перед сборкой проекта.

Сохраните проект и целевую папку сборки на твердотельном накопителе (SSD)

Твердотельные накопители (SSD) имеют более высокую скорость чтения/записи, чем традиционные жесткие диски (HDD). Преобразование кода IL в C++ и его компиляция требуют большого количества операций чтения/записи, поэтому более быстрое запоминающее устройство ускоряет этот процесс.

Включение проверок во время выполнения с помощью Il2CppSetOption

При использовании серверной части сценариев IL2CPP можно управлять тем, как il2cpp.exe генерирует код C++. Вы можете использовать атрибут Il2CppSetOption, чтобы включить или отключить следующие проверки во время выполнения:

Чтобы использовать атрибут Il2CppSetOption:

1. В каталоге, где установлена ваша версия Unity, перейдите в каталог Data\il2cpp в Windows или в каталог Contents/Frameworks/il2cpp в OS X.
2. Найдите исходный файл Il2CppSetOptionAttribute.cs.
3. Скопируйте исходный файл в папку Assets вашего проекта.

В приведенном ниже примере показано, как использовать атрибут Il2CppSetOption:

[Il2CppSetOption(Option.NullChecks, false)]
public static string MethodWithNullChecksDisabled()
{
var tmp = new object();
return tmp.ToString();
}


Вы можете применить атрибут Il2CppSetOption к типам, методам и свойствам. Unity использует атрибут из самой локальной области.

[Il2CppSetOption(Option.NullChecks, false)]
public class TypeWithNullChecksDisabled
{
public static string AnyMethod()
{
// Unity doesn’t perform null checks in this method.
var tmp = new object();
return tmp.ToString();
}

public string PropertyWithNullChecksDisabledOnGetterOnly
{
[Il2CppSetOption(Option.NullChecks, false)]
get
{
// Unity doesn’t perform null checks here.
var tmp = new object();
return tmp.ToString();
}
set
{
// Unity performs null checks here.
value.ToString();
}
}
}