Utilisation de .NET 4.x dans UnityUsing .NET 4.x in Unity

C# et .NET, les technologies sur lesquelles reposent les scripts Unity, ont continué à être mises à jour depuis que Microsoft les a initialement lancées en 2002.C# and .NET, the technologies underlying Unity scripting, have continued to receive updates since Microsoft originally released them in 2002. Toutefois, les développeurs Unity ne sont peut-être pas conscients du flux constant des nouvelles fonctionnalités ajoutées au langage C# et au .NET Framework.But Unity developers may not be aware of the steady stream of new features added to the C# language and .NET Framework. En effet, avant Unity 2017.1, Unity utilisait un runtime de script qui correspondait à .NET 3.5. Il lui manquait donc plusieurs années de mises à jour.That's because before Unity 2017.1, Unity has been using a .NET 3.5 equivalent scripting runtime, missing years of updates.

Avec la sortie d’Unity 2017.1, Unity a introduit une version expérimentale de son runtime de script, mise à niveau vers une version compatible avec .NET 4.6, 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. Dans Unity 2018.1, le runtime équivalent à .NET 4.x n’est plus considéré comme expérimental, alors que l’ancien runtime équivalent à .NET 3.5 est désormais considéré comme la version héritée.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. Avec la sortie d’Unity 2018.3, Unity prévoit de faire du runtime de script mis à niveau la sélection par défaut, et d’aller même encore plus loin en proposant une mise à jour pour le rendre compatible avec 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. Pour plus d’informations et pour obtenir les dernières mises à jour sur cette feuille de route, lisez le billet de blog consacré à Unity, ou visitez le forum des préversions de fonctionnalités de script expérimentales.For more information and the latest updates on this roadmap, read Unity's blog post or visit their Experimental Scripting Previews forum. En attendant, consultez les sections ci-dessous pour en savoir plus sur les nouvelles fonctionnalités disponibles dès maintenant avec le runtime de script .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érequisPrerequisites

Activation du runtime de script .NET 4.x dans UnityEnabling the .NET 4.x scripting runtime in Unity

Pour activer le runtime de script .NET 4.x, effectuez les étapes suivantes :To enable the .NET 4.x scripting runtime, take the following steps:

  1. Ouvrez PlayerSettings dans l’inspecteur Unity en sélectionnant Edit (Edition) > Project Settings (Paramètres du projet) > Player (Lecteur).Open PlayerSettings in the Unity Inspector by selecting Edit > Project Settings > Player.

  2. Sous le titre Configuration, cliquez sur la liste déroulante Scripting Runtime Version (Version du runtime de script), puis sélectionnez .NET 4.x Equivalent (Équivalent .NET 4.x).Under the Configuration heading, click the Scripting Runtime Version dropdown and select .NET 4.x Equivalent. Vous êtes invité à redémarrer Unity.You will be prompted to restart Unity.

Sélectionner l’équivalent .NET 4.x

Choix entre les profils .NET 4.x et .NET Standard 2.0Choosing between .NET 4.x and .NET Standard 2.0 profiles

Une fois que vous êtes passé au runtime de script équivalent à .NET 4.x, vous pouvez spécifier le niveau de compatibilité d’API dans le menu déroulant de PlayerSettings (Edit (Edition) > Project Settings (Paramètres du projet) > Player (Lecteur)).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). Nous avons deux options :There are two options:

  • .NET Standard 2,0..NET Standard 2.0. Ce profil correspond au profil .NET Standard 2.0 publié par .NET Foundation.This profile matches the .NET Standard 2.0 profile published by the .NET Foundation. Unity recommande .NET Standard 2.0 pour les nouveaux projets.Unity recommends .NET Standard 2.0 for new projects. Il est plus petit que .NET 4.x, ce qui est avantageux pour les plateformes limitées en taille.It's smaller than .NET 4.x, which is advantageous for size-constrained platforms. De plus, Unity s’est engagé à prendre en charge ce profil sur toutes les plateformes prises en charge par Unity.Additionally, Unity has committed to supporting this profile across all platforms that Unity supports.

  • .Net 4. x..NET 4.x. Ce profil permet d’accéder à la dernière API .NET 4.This profile provides access to the latest .NET 4 API. Il inclut tout le code disponible dans les bibliothèques de classes .NET Framework et prend également en charge les profils .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. Utilisez le profil .NET 4.x si votre projet nécessite une partie de l’API non incluse dans le profil .NET Standard 2.0.Use the .NET 4.x profile if your project requires part of the API not included in the .NET Standard 2.0 profile. Toutefois, certaines parties de cette API ne sont peut-être pas prises en charge sur toutes les plateformes d’Unity.However, some parts of this API may not be supported on all of Unity's platforms.

Pour en savoir plus sur ces options dans Unity, lisez le billet de blog.You can read more about these options in Unity's blog post.

Ajout de références d’assembly en cas d’utilisation du niveau de compatibilité d’API .NET 4.xAdding assembly references when using the .NET 4.x Api Compatibility Level

Quand vous utilisez le paramètre .NET Standard 2.0 de la liste déroulante API Compatibility Level (Niveau de compatibilité d’API), tous les assemblys du profil d’API sont référencés et utilisables.When using the .NET Standard 2.0 setting in the Api Compatibility Level dropdown, all assemblies in the API profile are referenced and usable. Toutefois, quand vous utilisez le profil .NET 4.x, qui est plus conséquent, certains des assemblys avec lesquels Unity est livré ne sont pas référencés par défaut.However, when using the larger .NET 4.x profile, some of the assemblies that Unity ships with aren't referenced by default. Pour utiliser ces API, vous devez ajouter manuellement une référence d’assembly.To use these APIs, you must manually add an assembly reference. Vous pouvez voir quels sont les assemblys avec lesquels Unity est livré dans le répertoire MonoBleedingEdge/lib/mono de votre installation de l’éditeur Unity :You can view the assemblies Unity ships with in the MonoBleedingEdge/lib/mono directory of your Unity editor installation:

Répertoire MonoBleedingEdge

Par exemple, si vous utilisez le profil .NET 4.x et si vous souhaitez utiliser HttpClient, vous devez ajouter une référence d’assembly pour 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. Sinon, le compilateur signale l’absence d’une référence d’assembly :Without it, the compiler will complain that you're missing an assembly reference:

référence d’assembly manquante

Visual Studio regénère les fichiers .csproj et .sln des projets Unity chaque fois qu’ils sont ouverts.Visual Studio regenerates .csproj and .sln files for Unity projects each time they're opened. Ainsi, vous ne pouvez pas ajouter de références d’assembly directement dans Visual Studio, car elles sont perdues à la réouverture du projet.As a result, you cannot add assembly references directly in Visual Studio because they'll be lost upon reopening the project. Au lieu de cela, vous devez utiliser un fichier texte spécial nommé CSC. rsp :Instead, a special text file named csc.rsp must be used:

  1. Créez un nouveau fichier texte nommé CSC. rsp dans le répertoire des ressources racine de votre projet Unity.Create a new text file named csc.rsp in your Unity project's root Assets directory.

  2. Sur la première ligne du fichier texte vide, entrez -r:System.Net.Http.dll, puis enregistrez le fichier.On the first line in the empty text file, enter: -r:System.Net.Http.dll and then save the file. Vous pouvez remplacer « System.Net.Http.dll » par n’importe quel assembly inclus auquel il peut manquer une référence.You can replace "System.Net.Http.dll" with any included assembly that might be missing a reference.

  3. Redémarrez l’éditeur Unity.Restart the Unity editor.

Tirer parti de la compatibilité .NETTaking advantage of .NET compatibility

En plus des nouvelles fonctionnalités de syntaxe et de langage C#, le runtime de script .NET 4.x permet aux utilisateurs d’Unity d’accéder à une vaste bibliothèque de packages .NET incompatibles avec le runtime de script .NET 3.5 existant.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.

Ajouter des packages NuGet à un projet UnityAdd packages from NuGet to a Unity project

NuGet est le gestionnaire de package pour .NET.NuGet is the package manager for .NET. NuGet est intégré à Visual Studio.NuGet is integrated into Visual Studio. Toutefois, les projets Unity nécessitent un processus spécial pour permettre l’ajout de packages NuGet.However, Unity projects require a special process to add NuGet packages. En effet, quand vous ouvrez un projet dans Unity, ses fichiers projet Visual Studio sont regénérés, ce qui entraîne l’annulation des configurations nécessaires.This is because when you open a project in Unity, its Visual Studio project files are regenerated, undoing necessary configurations. Pour ajouter un package NuGet à votre projet Unity, effectuez ce qui suit :To add a package from NuGet to your Unity project do the following:

  1. Parcourez NuGet pour localiser un package compatible à ajouter (.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). Cet exemple montre comment ajouter Json.NET (package souvent utilisé avec JSON) à un projet .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. Cliquez sur le bouton Télécharger :Click the Download button:

    bouton de téléchargement

  3. Localisez le fichier téléchargé, puis remplacez l’extension .nupkg par .zip.Locate the downloaded file and change the extension from .nupkg to .zip.

  4. Dans le fichier zip, accédez au répertoire lib/netstandard2.0, puis copiez le fichier Newtonsoft.Json.dll.Within the zip file, navigate to the lib/netstandard2.0 directory and copy the Newtonsoft.Json.dll file.

  5. Dans le dossier Assets racine de votre projet Unity, créez un dossier nommé Plugins.In your Unity project's root Assets folder, create a new folder named Plugins. Plugins est un nom de dossier spécial dans Unity.Plugins is a special folder name in Unity. Pour plus d’informations, consultez la documentation Unity.See the Unity documentation for more information.

  6. Collez le fichier Newtonsoft.Json.dll dans le répertoire Plugins de votre projet Unity.Paste the Newtonsoft.Json.dll file into your Unity project's Plugins directory.

  7. Créez un fichier nommé link.xml dans le répertoire Assets de votre projet Unity, puis ajoutez le code XML suivant.Create a file named link.xml in your Unity project's Assets directory and add the following XML. Ainsi, le processus de suppression du bytecode d’Unity n’entraîne pas la suppression des données nécessaires au moment de l’exportation vers une plateforme IL2CPP.This will ensure Unity's bytecode stripping process does not remove necessary data when exporting to an IL2CPP platform. Bien que cette étape soit spécifique à cette bibliothèque, vous pouvez rencontrer des problèmes avec d’autres bibliothèques qui utilisent Reflection de manière similaire.While this step is specific to this library, you may run into problems with other libraries that use Reflection in similar ways. Pour plus d’informations, consultez la documentation d’Unity sur ce sujet.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>
    

Tout étant en place, vous pouvez désormais utiliser le package 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.
    }
}

Ceci est un exemple simple d’utilisation d’une bibliothèque qui n’a aucune dépendance.This is a simple example of using a library which has no dependencies. Quand les packages NuGet reposent sur d’autres packages NuGet, vous devez télécharger ces dépendances manuellement et les ajouter au projet de la même manière.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.

Nouvelles fonctionnalités de syntaxe et de langageNew syntax and language features

L’utilisation du runtime de script mis à jour permet aux développeurs Unity d’accéder à C# 6 et à une multitude de nouvelles fonctionnalités de syntaxe et de langage.Using the updated scripting runtime gives Unity developers access to C# 6 and a host of new language features and syntax.

Initialiseurs de propriétés automatiquesAuto-property initializers

Dans le runtime de script .NET 3.5 d’Unity, la syntaxe des propriétés automatiques permet de définir facilement et rapidement les propriétés non initialisées. Toutefois, l’initialisation doit avoir lieu ailleurs dans votre 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. Désormais, avec le runtime .NET 4.x, il est possible d’initialiser les propriétés automatiques sur la même ligne :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;

Interpolation de chaîneString interpolation

Avec l’ancien runtime .NET 3.5, la concaténation de chaînes nécessitait une syntaxe compliquée.With the older .NET 3.5 runtime, string concatenation required awkward syntax. Désormais, avec le Runtime .NET 4. x, la fonctionnalité d' $ interpolation de chaîne permet d’insérer des expressions dans des chaînes dans une syntaxe plus directe et lisible :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}");

Membres expression-bodiedExpression-bodied members

Avec la nouvelle syntaxe C# disponible dans le runtime .NET 4.x, les expressions lambda peuvent remplacer le corps des fonctions pour les rendre plus succinctes :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;

Vous pouvez également utiliser des membres expression-bodied dans des propriétés en lecture seule :You can also use expression-bodied members in read-only properties:

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

Modèle asynchrone basé sur les tâches (TAP, Task-based Asynchronous Pattern)Task-based Asynchronous Pattern (TAP)

La programmation asynchrone permet d’effectuer des opérations longues sans entraîner d’absence de réponse de la part de votre application.Asynchronous programming allows time consuming operations to take place without causing your application to become unresponsive. Cette fonctionnalité permet également à votre code d’attendre la fin des opérations longues avant de poursuivre l’exécution de tout autre code dépendant des résultats de ces opérations.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. Par exemple, vous pouvez attendre la fin du chargement d’un fichier ou d’une opération réseau.For example, you could wait for a file to load or a network operation to complete.

Dans Unity, vous effectuez généralement la programmation asynchrone à l’aide de coroutines.In Unity, asynchronous programming is typically accomplished with coroutines. Toutefois, depuis C# 5, la méthode de programmation asynchrone préférée pour le développement .NET est le modèle TAP (modèle asynchrone basé sur les tâches) à l’aide des mots clés async et await avec 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. En résumé, dans une fonction async, vous pouvez appliquer await à l’exécution d’une tâche sans bloquer la mise à jour du reste de votre application :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.");
    }
}

TAP est un sujet complexe, avec des nuances spécifiques à Unity dont les développeurs doivent tenir compte.TAP is a complex subject, with Unity-specific nuances developers should consider. TAP n’est donc pas un remplacement universel des coroutines dans Unity. Toutefois, il s’agit d’un outil parmi d’autres à exploiter.As a result, TAP isn't a universal replacement for coroutines in Unity; however, it is another tool to leverage. La portée de cette fonctionnalité dépasse le cadre de cet article, mais certaines bonnes pratiques et astuces générales sont fournies ci-dessous.The scope of this feature is beyond this article, but some general best practices and tips are provided below.

Informations de référence pour bien démarrer avec TAP dans UnityGetting started reference for TAP with Unity

Ces conseils peuvent vous aider à bien démarrer avec TAP dans Unity :These tips can help you get started with TAP in Unity:

  • Les fonctions asynchrones destinées à être attendues doivent avoir le type de retour Task ou Task<TResult> .Asynchronous functions intended to be awaited should have the return type Task or Task<TResult>.
  • Les fonctions asynchrones qui retournent une tâche doivent avoir le suffixe « Async » accolé à leurs noms.Asynchronous functions that return a task should have the suffix "Async" appended to their names. Le suffixe « Async » permet d’indiquer qu’une fonction doit toujours être attendue.The "Async" suffix helps indicate that a function should always be awaited.
  • Utilisez uniquement le type de retour async void pour les fonctions qui déclenchent des fonctions asynchrones à partir du code synchrone classique.Only use the async void return type for functions that fire off async functions from traditional synchronous code. De telles fonctions ne peuvent pas être attendues et ne doivent pas comporter le suffixe « Async » dans leurs noms.Such functions cannot themselves be awaited and shouldn't have the "Async" suffix in their names.
  • Unity utilise UnitySynchronizationContext pour garantir l’exécution des fonctions asynchrones sur le thread principal par défaut.Unity uses the UnitySynchronizationContext to ensure async functions run on the main thread by default. L’API Unity n’est pas accessible en dehors du thread principal.The Unity API isn't accessible outside of the main thread.
  • Il est possible d’exécuter des tâches sur des threads d’arrière-plan avec des méthodes telles que Task.Run et Task.ConfigureAwait(false) .It's possible to run tasks on background threads with methods like Task.Run and Task.ConfigureAwait(false). Cette technique permet de décharger les opérations coûteuses du thread principal pour améliorer les performances.This technique is useful for offloading expensive operations from the main thread to enhance performance. Toutefois, l’utilisation de threads d’arrière-plan peut entraîner des problèmes difficiles à déboguer, par exemple les conditions de concurrence.However, using background threads can lead to problems that are difficult to debug, such as race conditions.
  • L’API Unity n’est pas accessible en dehors du thread principal.The Unity API isn't accessible outside the main thread.
  • Les tâches qui utilisent des threads ne sont pas prises en charge sur les builds Unity WebGL.Tasks that use threads aren't supported on Unity WebGL builds.

Différences entre coroutines et TAPDifferences between coroutines and TAP

Il existe des différences importantes entre les coroutines et TAP/async-await :There are some important differences between coroutines and TAP / async-await:

  • Les coroutines ne peuvent pas retourner de valeurs, contrairement à Task<TResult>.Coroutines cannot return values, but Task<TResult> can.
  • Vous ne pouvez pas mettre yield dans une instruction try-catch, ce qui complique la gestion des erreurs avec les coroutines.You cannot put a yield in a try-catch statement, making error handling difficult with coroutines. Toutefois, try-catch fonctionne avec TAP.However, try-catch works with TAP.
  • La fonctionnalité de coroutine d’Unity n’est pas disponible dans les classes qui ne dérivent pas de MonoBehaviour.Unity's coroutine feature isn't available in classes that don't derive from MonoBehaviour. TAP est idéal pour la programmation asynchrone dans de telles classes.TAP is great for asynchronous programming in such classes.
  • À ce stade, Unity ne suggère pas d’utiliser TAP en tant que remplacement systématique des coroutines.At this point, Unity doesn't suggest TAP as a wholesale replacement of coroutines. Le profilage est le seul moyen de connaître les résultats spécifiques d’une approche par rapport à l’autre pour un projet donné.Profiling is the only way to know the specific results of one approach versus the other for any given project.

Notes

Depuis Unity 2018.2, le débogage des méthodes asynchrones à l’aide de points d’arrêt n’est pas entièrement pris en charge. Toutefois, cette fonctionnalité est attendue dans 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.

opérateur nameofnameof operator

L’opérateur nameof obtient le nom de chaîne d’une variable, d’un type ou d’un membre.The nameof operator gets the string name of a variable, type, or member. Dans certains cas, nameof est utile, par exemple pour journaliser les erreurs et obtenir le nom de chaîne d’un enum :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));
}

Attributs d’informations de l’appelantCaller info attributes

Les attributs d’informations de l’appelant fournissent des informations sur l’appelant d’une méthode.Caller info attributes provide information about the caller of a method. Vous devez fournir une valeur par défaut pour chaque paramètre à utiliser avec un attribut d’informations de l’appelant :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 vous permet d’utiliser des fonctions statiques sans taper leur nom de classe.Using static allows you to use static functions without typing its class name. Avec using static, vous pouvez gagner de la place et du temps si vous devez utiliser plusieurs fonctions statiques provenant de la même 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
    }
}

Considérations relatives à IL2CPPIL2CPP Considerations

Quand vous exportez votre jeu sur des plateformes comme iOS, Unity utilise son moteur IL2CPP pour « transpiler » le code IL en code C++, lequel est ensuite compilé à l’aide du compilateur natif de la plateforme cible.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. Dans ce scénario, plusieurs fonctionnalités .NET ne sont pas prises en charge, par exemple certaines parties de Reflection et l’utilisation du mot clé dynamic.In this scenario, there are several .NET features which are not supported, such as parts of Reflection, and usage of the dynamic keyword. Bien que vous puissiez contrôler l’utilisation de ces fonctionnalités dans votre propre code, vous pouvez rencontrer des problèmes dans les DLL et kits SDK tiers qui n’ont pas été écrits en tenant compte des spécificités d’Unity et d’IL2CPP.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. Pour plus d’informations sur ce sujet, consultez la documentation sur les restrictions relatives aux scripts sur le site d’Unity.For more information on this topic, please see the Scripting Restrictions docs on Unity's site.

De plus, comme indiqué dans l’exemple Json.NET ci-dessus, Unity tente de supprimer le code inutilisé durant le processus d’exportation IL2CPP.Additionally, as mentioned in the Json.NET example above, Unity will attempt to strip out unused code during the IL2CPP export process. Bien que cela ne soit généralement pas un problème, avec les bibliothèques qui utilisent la réflexion, il peut accidentellement supprimer les propriétés ou les méthodes qui seront appelées au moment de l’exécution et qui ne peuvent pas être déterminées au moment de l’exportation.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. Pour résoudre ces problèmes, ajoutez un fichier link.xml au projet qui contient une liste d’assemblys et d’espaces de noms sur lesquels le processus de suppression ne doit pas s’exécuter.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. Pour plus d’informations, consultez la documentation d’Unity sur la suppression du bytecode.For full details, please see Unity's docs on bytecode stripping.

Exemple de projet Unity .NET 4.x.NET 4.x Sample Unity Project

Il s’agit d’exemples d’utilisation de plusieurs fonctionnalités .NET 4.x.The sample contains examples of several .NET 4.x features. Vous pouvez télécharger le projet ou voir le code source sur GitHub.You can download the project or view the source code on GitHub.

Ressources supplémentairesAdditional resources