Usar o .NET 4.x no UnityUsing .NET 4.x in Unity

C# e .NET, as tecnologias subjacentes ao script do Unity, continuam a receber atualizações, uma vez que a Microsoft as lançou originalmente em 2002.C# and .NET, the technologies underlying Unity scripting, have continued to receive updates since Microsoft originally released them in 2002. Mas os desenvolvedores do Unity podem não estar cientes do fluxo constante de novos recursos adicionados à linguagem C# e ao .NET Framework.But Unity developers may not be aware of the steady stream of new features added to the C# language and .NET Framework. Isso ocorre porque antes do Unity 2017.1, o Unity tem usado um runtime de script equivalente ao .NET 3.5, que ficou anos sem atualizações.That's because before Unity 2017.1, Unity has been using a .NET 3.5 equivalent scripting runtime, missing years of updates.

Com o lançamento do Unity 2017.1, o Unity introduziu uma versão experimental do seu runtime de script atualizado para uma versão compatível com o .NET 4.6 e o C# 6.With the release of Unity 2017.1, Unity introduced an experimental version of its scripting runtime upgraded to a .NET 4.6, C# 6 compatible version. No Unity 2018.1, o runtime equivalente ao .NET 4.x não é mais considerado experimental, enquanto o runtime equivalente ao .NET 3.5 mais antigo agora é considerado como a versão herdada.In Unity 2018.1, the .NET 4.x equivalent runtime is no longer considered experimental, while the older .NET 3.5 equivalent runtime is now considered to be the legacy version. E com o lançamento do Unity 2018.3, o Unity está projetando tornar o runtime de script atualizado a seleção padrão, além de atualizar mais, para o C# 7.And with the release of Unity 2018.3, Unity is projecting to make the upgraded scripting runtime the default selection, and to update even further to C# 7. Para obter mais informações e as atualizações mais recentes sobre este roteiro, leia a postagem de blog do Unity ou acesse seu Fórum de visualizações de script experimental.For more information and the latest updates on this roadmap, read Unity's blog post or visit their Experimental Scripting Previews forum. Enquanto isso, confira as seções abaixo para saber mais sobre os novos recursos disponíveis com o runtime de script do .NET 4.x.In the meantime, check out the sections below to learn more about the new features available now with the .NET 4.x scripting runtime.

Pré-requisitosPrerequisites

Habilitar o runtime de script do .NET 4.x no UnityEnabling the .NET 4.x scripting runtime in Unity

Para habilitar o runtime de script do .NET 4.x, execute as seguintes etapas:To enable the .NET 4.x scripting runtime, take the following steps:

  1. Abra as PlayerSettings no Inspetor do Unity, selecionando Editar > Configurações do projeto > Player.Open PlayerSettings in the Unity Inspector by selecting Edit > Project Settings > Player.

  2. No cabeçalho Configuração, clique no menu suspenso Versão do Runtime de Script e selecione Equivalente ao .NET 4.x.Under the Configuration heading, click the Scripting Runtime Version dropdown and select .NET 4.x Equivalent. Será solicitado que você reinicie o Unity.You will be prompted to restart Unity.

Selecionar o equivalente do .NET 4.x

Escolher entre perfis do .NET 4.x e do .NET Standard 2.0Choosing between .NET 4.x and .NET Standard 2.0 profiles

Depois de mudar para o runtime de script equivalente ao .NET 4.x, você pode especificar o Nível de compatibilidade de API usando o menu suspenso nas PlayerSettings (Editar > Configurações do projeto > Player).Once you've switched to the .NET 4.x equivalent scripting runtime, you can specify the Api Compatibility Level using the dropdown menu in the PlayerSettings (Edit > Project Settings > Player). Há duas opções:There are two options:

  • .NET Standard 2,0..NET Standard 2.0. Esse perfil corresponde ao perfil do .NET Standard 2.0 publicado pela .NET Foundation.This profile matches the .NET Standard 2.0 profile published by the .NET Foundation. O Unity recomenda o .NET Standard 2.0 para novos projetos.Unity recommends .NET Standard 2.0 for new projects. Ele é menor do que o .NET 4.x, o que é vantajoso para plataformas com restrições de tamanho.It's smaller than .NET 4.x, which is advantageous for size-constrained platforms. Além disso, o Unity se comprometeu a dar suporte a esse perfil em todas as plataformas compatíveis com o Unity.Additionally, Unity has committed to supporting this profile across all platforms that Unity supports.

  • .NET 4. x..NET 4.x. Esse perfil fornece acesso à mais recente API do .NET 4.This profile provides access to the latest .NET 4 API. Ele inclui todo o código disponível nas bibliotecas de classes do .NET Framework e também dá suporte a perfis do .NET Standard 2.0.It includes all of the code available in the .NET Framework class libraries and supports .NET Standard 2.0 profiles as well. Se seu projeto requer uma parte da API não incluída no perfil do .NET Standard 2.0, use o perfil do .NET 4.x.Use the .NET 4.x profile if your project requires part of the API not included in the .NET Standard 2.0 profile. No entanto, algumas partes dessa API podem não ser compatíveis com todas as plataformas do Unity.However, some parts of this API may not be supported on all of Unity's platforms.

Você pode ler mais sobre essas opções na postagem de blog do Unity.You can read more about these options in Unity's blog post.

Adicionar referências de assembly ao usar o nível de compatibilidade de API do .NET 4.xAdding assembly references when using the .NET 4.x Api Compatibility Level

Ao usar a configuração do .NET Standard 2.0 no menu suspenso Nível de compatibilidade de API, todos os assemblies no perfil de API são referenciados e utilizáveis.When using the .NET Standard 2.0 setting in the Api Compatibility Level dropdown, all assemblies in the API profile are referenced and usable. No entanto, ao usar o perfil maior do .NET 4.x, alguns dos assemblies que acompanham o Unity não são referenciados por padrão.However, when using the larger .NET 4.x profile, some of the assemblies that Unity ships with aren't referenced by default. Para usar essas APIs, você deve adicionar manualmente uma referência de assembly.To use these APIs, you must manually add an assembly reference. Você pode exibir os assemblies com os quais o Unity é fornecido no diretório MonoBleedingEdge/lib/mono da instalação do editor do Unity:You can view the assemblies Unity ships with in the MonoBleedingEdge/lib/mono directory of your Unity editor installation:

Diretório MonoBleedingEdge

Por exemplo, se estiver usando o perfil do .NET 4.x e desejar usar HttpClient, você deverá adicionar uma referência de assembly para System.Net.Http.dll.For example, if you're using the .NET 4.x profile and want to use HttpClient, you must add an assembly reference for System.Net.Http.dll. Sem ele, o compilador reclamará que uma referência de assembly está ausente:Without it, the compiler will complain that you're missing an assembly reference:

referência de assembly ausente

O Visual Studio regenera os arquivos .csproj e .sln para projetos do Unity cada vez que eles são abertos.Visual Studio regenerates .csproj and .sln files for Unity projects each time they're opened. Como resultado, não será possível adicionar referências de assembly diretamente no Visual Studio, porque elas serão perdidas ao reabrir o projeto.As a result, you cannot add assembly references directly in Visual Studio because they'll be lost upon reopening the project. Em vez disso, um arquivo de texto especial chamado CSC. rsp deve ser usado:Instead, a special text file named csc.rsp must be used:

  1. Crie um novo arquivo de texto chamado CSC. rsp no diretório de ativos raiz do projeto de Unity.Create a new text file named csc.rsp in your Unity project's root Assets directory.

  2. Na primeira linha no arquivo de texto vazio, digite: -r:System.Net.Http.dll e, em seguida, salve o arquivo.On the first line in the empty text file, enter: -r:System.Net.Http.dll and then save the file. Você pode substituir "System.Net.Http.dll" com qualquer assembly incluído no qual uma referência pode estar ausente.You can replace "System.Net.Http.dll" with any included assembly that might be missing a reference.

  3. Reinicie o editor do Unity.Restart the Unity editor.

Aproveitando a compatibilidade do .NETTaking advantage of .NET compatibility

Além dos novos recursos de linguagem de programação e de sintaxe do C#, o runtime de script do .NET 4.x oferece aos usuários do Unity acesso a uma enorme biblioteca de pacotes do .NET que são incompatíveis com o runtime de script do .NET 3.5 herdado.In addition to new C# syntax and language features, the .NET 4.x scripting runtime gives Unity users access to a huge library of .NET packages that are incompatible with the legacy .NET 3.5 scripting runtime.

Adicionar pacotes do NuGet a um projeto do UnityAdd packages from NuGet to a Unity project

O NuGet é o gerenciador de pacotes para o .NET.NuGet is the package manager for .NET. O NuGet é integrado ao Visual Studio.NuGet is integrated into Visual Studio. No entanto, os projetos do Unity exigem um processo especial para adicionar pacotes NuGet.However, Unity projects require a special process to add NuGet packages. Isso ocorre porque quando você abre um projeto no Unity, seus arquivos de projeto do Visual Studio são regenerados, desfazendo configurações necessárias.This is because when you open a project in Unity, its Visual Studio project files are regenerated, undoing necessary configurations. Para adicionar um pacote NuGet ao seu projeto Unity, faça o seguinte:To add a package from NuGet to your Unity project do the following:

  1. Procure no NuGet para localizar um pacote compatível que você deseja adicionar (.NET Standard 2.0 ou .NET 4.x).Browse NuGet to locate a compatible package you'd like to add (.NET Standard 2.0 or .NET 4.x). Este exemplo demonstra a adição do Json.NET, um pacote popular para trabalhar com JSON, a um projeto do .NET Standard 2.0.This example will demonstrate adding Json.NET, a popular package for working with JSON, to a .NET Standard 2.0 project.

  2. Clique no botão baixar :Click the Download button:

    botão download

  3. Localize o arquivo baixado e altere a extensão dele de .nupkg para .zip.Locate the downloaded file and change the extension from .nupkg to .zip.

  4. Dentro do arquivo zip, navegue até o diretório lib/netstandard2.0 e copie o arquivo Newtonsoft.Json.dl.Within the zip file, navigate to the lib/netstandard2.0 directory and copy the Newtonsoft.Json.dll file.

  5. Na pasta Ativos na raiz do projeto do Unity, crie uma nova pasta chamada Plugins.In your Unity project's root Assets folder, create a new folder named Plugins. Plugins é um nome de pasta especial no Unity.Plugins is a special folder name in Unity. Veja a documentação do Unity para obter mais informações.See the Unity documentation for more information.

  6. Cole o arquivo Newtonsoft.Json.dll no diretório Plugins do projeto do Unity.Paste the Newtonsoft.Json.dll file into your Unity project's Plugins directory.

  7. Crie um arquivo chamado link.xml no diretório Ativos do seu projeto do Unity e adicione o XML a seguir.Create a file named link.xml in your Unity project's Assets directory and add the following XML. Isso garantirá que o processo de remoção de código de bytes do Unity não remova os dados necessários ao exportar para uma plataforma IL2CPP.This will ensure Unity's bytecode stripping process does not remove necessary data when exporting to an IL2CPP platform. Embora esta etapa seja específica para essa biblioteca, você poderá encontrar problemas com outras bibliotecas que usam reflexão de maneiras semelhantes.While this step is specific to this library, you may run into problems with other libraries that use Reflection in similar ways. Para obter mais informações, consulte a documentação do Unity sobre esse tópico.For more information, please see Unity's docs on this topic.

    <linker>
      <assembly fullname="System.Core">
        <type fullname="System.Linq.Expressions.Interpreter.LightLambda" preserve="all" />
      </assembly>
    </linker>
    

Com tudo pronto, agora você pode usar o pacote Json.NET.With everything in place, you can now use the Json.NET package.

using Newtonsoft.Json;
using UnityEngine;

public class JSONTest : MonoBehaviour
{
    class Enemy
    {
        public string Name { get; set; }
        public int AttackDamage { get; set; }
        public int MaxHealth { get; set; }
    }
    private void Start()
    {
        string json = @"{
            'Name': 'Ninja',
            'AttackDamage': '40'
            }";

        var enemy = JsonConvert.DeserializeObject<Enemy>(json);

        Debug.Log($"{enemy.Name} deals {enemy.AttackDamage} damage.");
        // Output:
        // Ninja deals 40 damage.
    }
}

Esse é um exemplo simples do uso de uma biblioteca sem dependências.This is a simple example of using a library which has no dependencies. Quando os pacotes do NuGet dependem de outros pacotes do NuGet, você precisa baixar essas dependências manualmente e adicioná-las ao projeto da mesma maneira.When NuGet packages rely on other NuGet packages, you would need to download these dependencies manually and add them to the project in the same way.

Novos recursos de linguagem e de sintaxeNew syntax and language features

Usar o runtime de script atualizado dá aos desenvolvedores do Unity acesso a C# 6 e a uma série de novos recursos de linguagem e de sintaxe.Using the updated scripting runtime gives Unity developers access to C# 6 and a host of new language features and syntax.

Inicializadores de propriedade automáticaAuto-property initializers

No runtime de script do Unity .NET 3.5, a sintaxe de propriedade automática torna mais fácil definir rapidamente as propriedades não inicializadas, mas a inicialização precisa ocorrer em outro lugar no seu script.In Unity's .NET 3.5 scripting runtime, the auto-property syntax makes it easy to quickly define uninitialized properties, but initialization has to happen elsewhere in your script. Agora, com o runtime .NET 4.x, é possível inicializar as propriedades automáticas na mesma linha:Now with the .NET 4.x runtime, it's possible to initialize auto-properties in the same line:

// .NET 3.5
public int Health { get; set; } // Health has to be initialized somewhere else, like Start()

// .NET 4.x
public int Health { get; set; } = 100;

Interpolação de cadeia de caracteresString interpolation

Com o runtime mais antigo do .NET 3.5, a concatenação de cadeia de caracteres exigia uma sintaxe estranha.With the older .NET 3.5 runtime, string concatenation required awkward syntax. Agora, com o tempo de execução do .NET 4. x, o recurso de $ interpolação de cadeia de caracteres permite que as expressões sejam inseridas em cadeias em uma sintaxe mais direta e legível:Now with the .NET 4.x runtime, the $ string interpolation feature allows expressions to be inserted into strings in a more direct and readable syntax:

// .NET 3.5
Debug.Log(String.Format("Player health: {0}", Health)); // or
Debug.Log("Player health: " + Health);

// .NET 4.x
Debug.Log($"Player health: {Health}");

Membros aptos para expressãoExpression-bodied members

Com a mais nova sintaxe C# disponível no runtime do .NET 4.x, expressões lambda podem substituir o corpo de funções para torná-las mais sucintas:With the newer C# syntax available in the .NET 4.x runtime, lambda expressions can replace the body of functions to make them more succinct:

// .NET 3.5
private int TakeDamage(int amount)
{
    return Health -= amount;
}

// .NET 4.x
private int TakeDamage(int amount) => Health -= amount;

Você também pode usar membros aptos para expressão em propriedades somente leitura:You can also use expression-bodied members in read-only properties:

// .NET 4.x
public string PlayerHealthUiText => $"Player health: {Health}";

Padrão assíncrono baseado em tarefa (TAP)Task-based Asynchronous Pattern (TAP)

A programação assíncrona permite que operações demoradas sejam realizadas sem que isso faça com que o aplicativo pare de responder.Asynchronous programming allows time consuming operations to take place without causing your application to become unresponsive. Essa funcionalidade também permite que seu código aguarde a conclusão de operações demoradas antes de continuar com código que dependa dos resultados dessas operações.This functionality also allows your code to wait for time consuming operations to finish before continuing with code that depends on the results of these operations. Por exemplo, você poderia esperar o carregamento de um arquivo ou a conclusão de uma operação de rede.For example, you could wait for a file to load or a network operation to complete.

No Unity, a programação assíncrona normalmente é feita com corrotinas.In Unity, asynchronous programming is typically accomplished with coroutines. No entanto, desde o C# 5, o método preferencial de programação assíncrona no desenvolvimento do .NET é o TAP (Padrão Assíncrono Baseado em Tarefa) usando o async e palavras-chave await com System.Threading.Task.However, since C# 5, the preferred method of asynchronous programming in .NET development has been the Task-based Asynchronous Pattern (TAP) using the async and await keywords with System.Threading.Task. Em resumo, em uma função async, você pode await a conclusão de uma tarefa sem bloquear a atualização do resto do seu aplicativo:In summary, in an async function you can await a task's completion without blocking the rest of your application from updating:

// Unity coroutine
using UnityEngine;
public class UnityCoroutineExample : MonoBehaviour
{
    private void Start()
    {
        StartCoroutine(WaitOneSecond());
        DoMoreStuff(); // This executes without waiting for WaitOneSecond
    }
    private IEnumerator WaitOneSecond()
    {
        yield return new WaitForSeconds(1.0f);
        Debug.Log("Finished waiting.");
    }
}
// .NET 4.x async-await
using UnityEngine;
using System.Threading.Tasks;
public class AsyncAwaitExample : MonoBehaviour
{
    private async void Start()
    {
        Debug.Log("Wait.");
        await WaitOneSecondAsync();
        DoMoreStuff(); // Will not execute until WaitOneSecond has completed
    }
    private async Task WaitOneSecondAsync()
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
        Debug.Log("Finished waiting.");
    }
}

O TAP é um assunto complexo, com nuances específicas do Unity que os desenvolvedores devem considerar.TAP is a complex subject, with Unity-specific nuances developers should consider. Como resultado, o TAP não é uma substituição universal para corrotinas no Unity; no entanto, é outra ferramenta que se pode aproveitar.As a result, TAP isn't a universal replacement for coroutines in Unity; however, it is another tool to leverage. O escopo desse recurso está além do abordado por este artigo, mas algumas dicas e práticas recomendadas gerais são fornecidas abaixo.The scope of this feature is beyond this article, but some general best practices and tips are provided below.

Referência de introdução ao TAP com o UnityGetting started reference for TAP with Unity

Estas dicas podem ajudar você a começar a usar o TAP no Unity:These tips can help you get started with TAP in Unity:

  • As funções assíncronas destinadas a serem aguardadas devem ter o tipo de retorno Task ou Task<TResult> .Asynchronous functions intended to be awaited should have the return type Task or Task<TResult>.
  • Funções assíncronas que retornam uma tarefa devem ter o sufixo "Async" acrescentado aos seus nomes.Asynchronous functions that return a task should have the suffix "Async" appended to their names. O sufixo "Async" ajuda a indicar que uma função deve sempre ser aguardada.The "Async" suffix helps indicate that a function should always be awaited.
  • Use somente o tipo de retorno async void para funções que disparam funções assíncronas do código síncrono tradicional.Only use the async void return type for functions that fire off async functions from traditional synchronous code. Essas funções em si não podem ser esperadas e não devem ter o sufixo "Async" em seus nomes.Such functions cannot themselves be awaited and shouldn't have the "Async" suffix in their names.
  • O Unity usa o UnitySynchronizationContext para garantir que funções assíncronas sejam executadas no thread principal por padrão.Unity uses the UnitySynchronizationContext to ensure async functions run on the main thread by default. A API do Unity não está acessível fora do thread principal.The Unity API isn't accessible outside of the main thread.
  • É possível executar tarefas em threads em segundo plano com métodos como Task.Run e Task.ConfigureAwait(false) .It's possible to run tasks on background threads with methods like Task.Run and Task.ConfigureAwait(false). Essa técnica é útil para o descarregamento de operações onerosas do thread principal para aprimorar o desempenho.This technique is useful for offloading expensive operations from the main thread to enhance performance. No entanto, o uso de threads em segundo plano pode levar a problemas difíceis de depurar, tais como condições de corrida.However, using background threads can lead to problems that are difficult to debug, such as race conditions.
  • A API do Unity não está acessível fora do thread principal.The Unity API isn't accessible outside the main thread.
  • Tarefas que usam threads não são compatíveis com builds WebGL do Unity.Tasks that use threads aren't supported on Unity WebGL builds.

Diferenças entre corrotinas e TAPDifferences between coroutines and TAP

Há algumas diferenças importantes entre corrotinas e TAP/async-await:There are some important differences between coroutines and TAP / async-await:

  • As corrotinas não podem retornar valores, mas Task<TResult> pode.Coroutines cannot return values, but Task<TResult> can.
  • Você não pode colocar um yield em uma instrução try-catch, tornando o tratamento de erro difícil com as corrotinas.You cannot put a yield in a try-catch statement, making error handling difficult with coroutines. No entanto, o try-catch funciona com o TAP.However, try-catch works with TAP.
  • O recurso de co-rotina do Unity não está disponível nas classes que não derivam de MonoBehaviour.Unity's coroutine feature isn't available in classes that don't derive from MonoBehaviour. TAP é ótimo para programação assíncrona nessas classes.TAP is great for asynchronous programming in such classes.
  • Atualmente, o Unity não sugere TAP como uma substituição completa de corrotinas.At this point, Unity doesn't suggest TAP as a wholesale replacement of coroutines. A criação de perfil é a única maneira de saber os resultados específicos de uma abordagem em relação à outra para qualquer projeto.Profiling is the only way to know the specific results of one approach versus the other for any given project.

Observação

Desde o Unity 2018.2, métodos assíncronos com pontos de interrupção de depuração não são totalmente compatíveis; no entanto, essa funcionalidade é esperada no Unity 2018.3.As of Unity 2018.2, debugging async methods with break points isn't fully supported; however, this functionality is expected in Unity 2018.3.

operador nameofnameof operator

O operador nameof obtém o nome de cadeia de caracteres de uma variável, tipo ou membro.The nameof operator gets the string name of a variable, type, or member. Alguns casos em que nameof é útil são o registro de erros e a obtenção do nome da cadeia de caracteres de uma enumeração:Some cases where nameof comes in handy are logging errors, and getting the string name of an enum:

// Get the string name of an enum:
enum Difficulty {Easy, Medium, Hard};
private void Start()
{
    Debug.Log(nameof(Difficulty.Easy));
    RecordHighScore("John");
    // Output:
    // Easy
    // playerName
}
// Validate parameter:
private void RecordHighScore(string playerName)
{
    Debug.Log(nameof(playerName));
    if (playerName == null) throw new ArgumentNullException(nameof(playerName));
}

Atributos de informações do chamadorCaller info attributes

Os atributos de informações do chamador fornecem informações sobre o chamador de um método.Caller info attributes provide information about the caller of a method. Você deve fornecer um valor padrão para cada parâmetro que você deseja usar com um atributo de informações do chamador:You must provide a default value for each parameter you want to use with a Caller Info attribute:

private void Start ()
{
    ShowCallerInfo("Something happened.");
}
public void ShowCallerInfo(string message,
        [System.Runtime.CompilerServices.CallerMemberName] string memberName = "",
        [System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "",
        [System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0)
{
    Debug.Log($"message: {message}");
    Debug.Log($"member name: {memberName}");
    Debug.Log($"source file path: {sourceFilePath}");
    Debug.Log($"source line number: {sourceLineNumber}");
}
// Output:
// Something happened
// member name: Start
// source file path: D:\Documents\unity-scripting-upgrade\Unity Project\Assets\CallerInfoTest.cs
// source line number: 10

Using staticUsing static

Using static permite que você use funções estáticas sem digitar seu nome de classe.Using static allows you to use static functions without typing its class name. Com o using static, você poderá economizar espaço e tempo se precisar usar várias funções estáticas da mesma classe:With using static, you can save space and time if you need to use several static functions from the same class:

// .NET 3.5
using UnityEngine;
public class Example : MonoBehaviour
{
    private void Start ()
    {
        Debug.Log(Mathf.RoundToInt(Mathf.PI));
        // Output:
        // 3
    }
}
// .NET 4.x
using UnityEngine;
using static UnityEngine.Mathf;
public class UsingStaticExample: MonoBehaviour
{
    private void Start ()
    {
        Debug.Log(RoundToInt(PI));
        // Output:
        // 3
    }
}

Considerações de IL2CPPIL2CPP Considerations

Ao exportar seu jogo para plataformas como iOS, o Unity usará seu mecanismo IL2CPP para "transcompilar" o IL para código C++ que é então compilado usando o compilador nativo da plataforma de destino.When exporting your game to platforms like iOS, Unity will use its IL2CPP engine to "transpile" IL to C++ code which is then compiled using the native compiler of the target platform. Nesse cenário, há vários recursos do .NET que não são compatíveis, tais como partes de reflexão e o uso da palavra-chave dynamic.In this scenario, there are several .NET features which are not supported, such as parts of Reflection, and usage of the dynamic keyword. Embora você possa controlar o uso desses recursos em seu próprio código, você pode encontrar problemas ao usar DLLs de terceiros e SDKs que não foram escritos com o Unity e o IL2CPP em mente.While you can control using these features in your own code, you may run into problems using 3rd party DLLs and SDKs which were not written with Unity and IL2CPP in mind. Para obter mais informações sobre esse tópico, veja a documentação sobre restrições de script no site do Unity.For more information on this topic, please see the Scripting Restrictions docs on Unity's site.

Além disso, conforme mencionado no exemplo de Json.NET acima, o Unity tentará retirar o código não utilizado durante o processo de exportação de IL2CPP.Additionally, as mentioned in the Json.NET example above, Unity will attempt to strip out unused code during the IL2CPP export process. Embora isso normalmente não seja um problema, com bibliotecas que usam reflexão, ele pode remover acidentalmente Propriedades ou métodos que serão chamados em tempo de execução que não podem ser determinados no momento da exportação.While this typically isn't an issue, with libraries that use Reflection, it can accidentally strip out properties or methods that will be called at run time that can't be determined at export time. Para corrigir esses problemas, adicione um arquivo link.xml ao seu projeto que contém uma lista de assemblies e namespaces nos quais não executar o processo de remoção.To fix these issues, add a link.xml file to your project which contains a list of assemblies and namespaces to not run the stripping process against. Para obter detalhes completos, veja a documentação do Unity sobre a remoção de código de bytes.For full details, please see Unity's docs on bytecode stripping.

Projeto do Unity de exemplo do .NET 4.x.NET 4.x Sample Unity Project

A amostra contém exemplos de vários recursos do .NET 4.x.The sample contains examples of several .NET 4.x features. Você pode baixar o projeto ou exibir o código-fonte no GitHub.You can download the project or view the source code on GitHub.

Recursos adicionaisAdditional resources