Die vollständige Einführung in die asynchrone Programmierung für die Unity-Entwicklung

Einige Aufgaben in der Spieleentwicklung sind nicht synchron, sondern asynchron. Dies bedeutet, dass sie nicht linear innerhalb des Spielcodes ausgeführt werden. Einige dieser asynchronen Aufgaben können recht lange dauern, während andere mit intensiven Berechnungen verbunden sind. Einige der häufigsten asynchronen Gaming-Aufgaben sind wie folgt: Durchführen von Netzwerkanfragen Laden von Szenen, Ressourcen und anderen Assets Dateien lesen und schreiben Künstliche Intelligenz zur Entscheidungsfindung Lange Animationssequenzen Verarbeitung großer Datenmengen Wegfindung Da nun der gesamte Unity-Code in einem Thread ausgeführt wird, ist es von entscheidender Bedeutung, dass jede Aufgabe wie eine der oben genannten, wenn sie synchron ausgeführt würde, zur Blockierung des Hauptthreads und damit zu Frame-Drops führen würde. Hallo zusammen, mein Name ist Dmitrii Ivashchenko und ich bin der Leiter des Entwicklungsteams bei MY.GAMES. In diesem Artikel werden wir über die Vermeidung solcher Probleme sprechen. Wir empfehlen asynchrone Programmiertechniken, um diese Aufgaben in einem separaten Thread auszuführen, sodass der Hauptthread frei bleibt, um andere Aufgaben auszuführen. Dies wird dazu beitragen, ein reibungsloses und reaktionsschnelles Gameplay und (hoffentlich) zufriedene Spieler zu gewährleisten. Coroutinen Lassen Sie uns zunächst über Sie wurden 2011 in Unity eingeführt, noch bevor async/await in .NET erschien. In Unity ermöglichen uns Coroutinen, eine Reihe von Anweisungen über mehrere Frames hinweg auszuführen, anstatt sie alle auf einmal auszuführen. Sie ähneln Threads, sind jedoch leichtgewichtig und in die Update-Schleife von Unity integriert, wodurch sie sich gut für die Spieleentwicklung eignen. Coroutinen sprechen. (Historisch gesehen waren Coroutinen übrigens die erste Möglichkeit, asynchrone Operationen in Unity auszuführen, daher geht es in den meisten Artikeln im Internet um sie.) Um eine Coroutine zu erstellen, müssen Sie eine Funktion mit dem Rückgabetyp deklarieren. Diese Funktion kann jede Logik enthalten, die die Coroutine ausführen soll. IEnumerator Um eine Coroutine zu starten, müssen Sie die Methode auf einer Instanz aufrufen und die Coroutine-Funktion als Argument übergeben: StartCoroutine MonoBehaviour public class Example : MonoBehaviour { void Start() { StartCoroutine(MyCoroutine()); } IEnumerator MyCoroutine() { Debug.Log("Starting coroutine"); yield return null; Debug.Log("Executing coroutine"); yield return null; Debug.Log("Finishing coroutine"); } } In Unity sind mehrere Ertragsanweisungen verfügbar, z. B. , , , , und einige andere. Es ist wichtig zu bedenken, dass ihre Verwendung zu Zuordnungen führt und daher nach Möglichkeit wiederverwendet werden sollte. WaitForSeconds WaitForEndOfFrame WaitForFixedUpdate WaitForSecondsRealtime WaitUntil Betrachten Sie beispielsweise diese Methode aus der Dokumentation: IEnumerator Fade() { Color c = renderer.material.color; for (float alpha = 1f; alpha >= 0; alpha -= 0.1f) { ca = alpha; renderer.material.color = c; yield return new WaitForSeconds(.1f); } } Mit jeder Iteration der Schleife wird eine neue Instanz von erstellt. Stattdessen können wir die Erstellung außerhalb der Schleife verschieben und Zuweisungen vermeiden: new WaitForSeconds(.1f) IEnumerator Fade() { Color c = renderer.material.color; **var waitForSeconds = new WaitForSeconds(0.2f);** for (float alpha = 1f; alpha >= 0; alpha -= 0.1f) { ca = alpha; renderer.material.color = c; yield return **waitForSeconds**; } } Eine weitere wichtige Eigenschaft ist, dass mit allen von Unity bereitgestellten Methoden verwendet werden kann, da s Nachkommen von sind: yield return Async AsyncOperation YieldInstruction yield return SceneManager.LoadSceneAsync("path/to/scene.unity"); Einige mögliche Fallstricke von Coroutinen Abgesehen davon haben Coroutinen auch einige Nachteile, die es zu beachten gilt: Es ist unmöglich, das Ergebnis einer langen Operation zurückzugeben. Sie benötigen weiterhin Rückrufe, die an die Coroutine übergeben und aufgerufen werden, wenn sie fertig ist, um Daten daraus zu extrahieren. Eine Coroutine ist streng an das gebunden, das sie startet. Wenn das ausgeschaltet oder zerstört wird, wird die Coroutine nicht mehr verarbeitet. MonoBehaviour GameObject Die Struktur kann aufgrund der Yield-Syntax nicht verwendet werden. try-catch-finally Mindestens ein Frame vergeht nach der , bevor der nächste Code ausgeführt wird. yield return Zuordnung des Lambda und der Coroutine selbst Versprechen sind ein Muster, um asynchrone Vorgänge zu organisieren und besser lesbar zu machen. Sie sind aufgrund ihrer Verwendung in vielen JavaScript-Bibliotheken von Drittanbietern populär geworden und werden seit ES6 nativ implementiert. Versprechen Wenn Sie Promises verwenden, geben wir sofort ein Objekt von Ihrer asynchronen Funktion zurück. Dadurch kann der Aufrufer auf die Lösung (oder einen Fehler) des Vorgangs warten. Im Wesentlichen bedeutet dies, dass asynchrone Methoden Werte zurückgeben und sich wie synchrone Methoden „verhalten“ können: Anstatt den endgültigen Wert sofort zurückzugeben, geben sie ein „Versprechen“, dass sie irgendwann in der Zukunft einen Wert zurückgeben werden. Es gibt mehrere Promises-Implementierungen für Unity: C-Sharp-Versprechen UnityFx.Async C#-Versprechen du versprichst Die Interaktion mit einem Promise erfolgt hauptsächlich über . Callback-Funktionen Sie können eine Rückruffunktion definieren, die aufgerufen wird, wenn ein Versprechen aufgelöst wird, und eine andere Rückruffunktion, die aufgerufen wird, wenn das Versprechen abgelehnt wird. Diese Rückrufe erhalten das Ergebnis der asynchronen Operation als Argumente, die dann zur Ausführung weiterer Operationen verwendet werden können. Gemäß diesen Promises/A+-Organisation kann ein Promise einen von drei Zuständen haben: Spezifikationen der : Der Anfangszustand bedeutet, dass der asynchrone Vorgang noch läuft und das Ergebnis des Vorgangs noch nicht bekannt ist. Pending ( ): Der gelöste Zustand wird von einem Wert begleitet, der das Ergebnis des Vorgangs darstellt. Fulfilled Resolved : Wenn der asynchrone Vorgang aus irgendeinem Grund fehlschlägt, wird das Versprechen als „abgelehnt“ bezeichnet. Dem abgelehnten Status ist der Grund für das Scheitern beigefügt. Rejected Mehr zu Versprechen Darüber hinaus können Versprechen miteinander verkettet werden, sodass das Ergebnis eines Versprechens zur Bestimmung des Ergebnisses eines anderen Versprechens verwendet werden kann. Sie können beispielsweise ein Promise erstellen, das einige Daten von einem Server abruft, und diese Daten dann verwenden, um ein weiteres Promise zu erstellen, das einige Berechnungen und andere Aktionen durchführt: var promise = MakeRequest("https://some.api") .Then(response => Parse(response)) .Then(result => OnRequestSuccess(result)) .Then(() => PlaySomeAnimation()) .Catch(exception => OnRequestFailed(exception)); Hier ist ein Beispiel für die Organisation einer Methode, die einen asynchronen Vorgang ausführt: public IPromise MakeRequest(string url) { // Create a new promise object var promise = new Promise (); // Create a new web client using var client = new WebClient(); // Add a handler for the DownloadStringCompleted event client.DownloadStringCompleted += (sender, eventArgs) => { // If an error occurred, reject the promise if (eventArgs.Error != null) { promise.Reject(eventArgs.Error); } // Otherwise, resolve the promise with the result else { promise.Resolve(eventArgs.Result); } }; // Start the download asynchronously client.DownloadStringAsync(new Uri(url), null); // Return the promise return promise; } Wir könnten Coroutinen auch in ein einschließen: Promise void Start() { // Load the scene and then show the intro animation LoadScene("path/to/scene.unity") .Then(() => ShowIntroAnimation()) .Then( ... ); } // Load a scene and return a promise Promise LoadScene(string sceneName) { // Create a new promise var promise = new Promise(); // Start a coroutine to load the scene StartCoroutine(LoadSceneRoutine(promise, sceneName)); // Return the promise return promise; } IEnumerator LoadSceneRoutine(Promise promise, string sceneName) { // Load the scene asynchronously yield return SceneManager.LoadSceneAsync(sceneName); // Resolve the promise once the scene is loaded promise.Resolve(); } Und natürlich können Sie mit / und / jede beliebige Kombination der Versprechen-Ausführungsreihenfolge organisieren: ThenAll Promise.All ThenRace Promise.Race // Execute the following two promises in sequence Promise.Sequence( () => Promise.All( // Execute the two promises in parallel RunAnimation("Foo"), PlaySound("Bar") ), () => Promise.Race( // Execute the two promises in a race RunAnimation("One"), PlaySound("Two") ) ); Die „vielversprechenden“ Teile von Versprechen Trotz aller Benutzerfreundlichkeit haben Versprechen auch einige Nachteile: : Das Erstellen von Promises ist im Vergleich zur Verwendung anderer Methoden der asynchronen Programmierung, wie etwa Coroutinen, mit zusätzlichem Overhead verbunden. In manchen Fällen kann dies zu einer verminderten Leistung führen. Overhead : Das Debuggen von Promises kann schwieriger sein als das Debuggen anderer asynchroner Programmiermuster. Es kann schwierig sein, den Ausführungsfluss zu verfolgen und die Fehlerquelle zu identifizieren. Debuggen : Die Ausnahmebehandlung kann bei Promises im Vergleich zu anderen asynchronen Programmiermustern komplexer sein. Es kann schwierig sein, Fehler und Ausnahmen zu verwalten, die innerhalb einer Promise-Kette auftreten. Ausnahmebehandlung Asynchrone/wartende Aufgaben Die Async/Await-Funktion ist seit Version 5.0 (2012) Teil von C# und wurde in Unity 2017 mit der Implementierung der .NET 4.x-Laufzeit eingeführt. In der Geschichte von .NET lassen sich folgende Phasen unterscheiden: (Event-based Asynchronous Pattern): Dieser Ansatz basiert auf Ereignissen, die nach Abschluss einer Operation ausgelöst werden, und einer regulären Methode, die diese Operation aufruft. EAP (Asynchronous Programming Model): Dieser Ansatz basiert auf zwei Methoden. Die Methode gibt die Schnittstelle zurück. Die -Methode akzeptiert ; Wenn der Vorgang zum Zeitpunkt des Aufrufs nicht abgeschlossen ist, wird der Thread blockiert. APM BeginSmth IAsyncResult EndSmth IAsyncResult EndSmth (Task-based Asynchronous Pattern): Dieses Konzept wurde durch die Einführung von async/await und den Typen und verbessert. TAP Task Task Die vorherigen Ansätze wurden aufgrund des Erfolgs des letzten Ansatzes obsolet. Um eine asynchrone Methode zu erstellen, muss die Methode mit dem Schlüsselwort gekennzeichnet sein, ein „ enthalten und der Rückgabewert muss , oder sein (nicht empfohlen). async await Task Task void public async Task Example() { SyncMethodA(); await Task.Delay(1000); // the first async operation SyncMethodB(); await Task.Delay(2000); // the second async operation SyncMethodC(); await Task.Delay(3000); // the third async operation } In diesem Beispiel erfolgt die Ausführung wie folgt: Zunächst wird der Code vor dem Aufruf des ersten asynchronen Vorgangs ( ) ausgeführt. SyncMethodA Der erste asynchrone Vorgang wird gestartet und wird voraussichtlich ausgeführt. In der Zwischenzeit wird der Code gespeichert, der aufgerufen werden soll, wenn der asynchrone Vorgang abgeschlossen ist (die „Fortsetzung“). await Task.Delay(1000) Nachdem der erste asynchrone Vorgang abgeschlossen ist, beginnt die „Fortsetzung“ – der Code, bis der nächste asynchrone Vorgang ( ) ausgeführt wird. SyncMethodB Der zweite asynchrone Vorgang ( ) wird gestartet und wird voraussichtlich ausgeführt. Gleichzeitig bleibt die Fortsetzung – der Code nach der zweiten asynchronen Operation ( ) – erhalten. await Task.Delay(2000) SyncMethodC Nach Abschluss des zweiten asynchronen Vorgangs wird ausgeführt, gefolgt von der Ausführung und dem Warten auf den dritten asynchronen . SyncMethodC await Task.Delay(3000) Dies ist eine vereinfachte Erklärung, da async/await tatsächlich syntaktischer Zucker ist, der das bequeme Aufrufen asynchroner Methoden und das Warten auf deren Abschluss ermöglicht. Sie können auch jede beliebige Kombination von Ausführungsaufträgen mithilfe von und organisieren: WhenAll WhenAny var allTasks = Task.WhenAll( Task.Run(() => { /* ... */ }), Task.Run(() => { /* ... */ }), Task.Run(() => { /* ... */ }) ); allTasks.ContinueWith(t => { Console.WriteLine("All the tasks are completed"); }); var anyTask = Task.WhenAny( Task.Run(() => { /* ... */ }), Task.Run(() => { /* ... */ }), Task.Run(() => { /* ... */ }) ); anyTask.ContinueWith(t => { Console.WriteLine("One of tasks is completed"); }); IAsyncStateMachine Der -Compiler wandelt asynchrone/await-Aufrufe in eine Zustandsmaschine um, bei der es sich um einen sequentiellen Satz von Aktionen handelt, die ausgeführt werden müssen, um den asynchronen Vorgang abzuschließen. C# IAsyncStateMachine Jedes Mal, wenn Sie eine Warteoperation aufrufen, schließt die Zustandsmaschine ihre Arbeit ab und wartet auf den Abschluss dieser Operation. Anschließend führt sie die nächste Operation weiter aus. Dies ermöglicht die Ausführung asynchroner Vorgänge im Hintergrund, ohne den Hauptthread zu blockieren, und macht außerdem asynchrone Methodenaufrufe einfacher und lesbarer. Somit wird die in die Erstellung und Initialisierung eines Zustandsautomaten mit der Annotation umgewandelt, und der Zustandsautomat selbst verfügt über eine Anzahl von Zuständen, die der Anzahl der Warteaufrufe entspricht. Example [AsyncStateMachine(typeof(ExampleStateMachine))] Beispiel der transformierten Methode Example [AsyncStateMachine(typeof(ExampleStateMachine))] public /*async*/ Task Example() { // Create a new instance of the ExampleStateMachine class ExampleStateMachine stateMachine = new ExampleStateMachine(); // Create a new AsyncTaskMethodBuilder and assign it to the taskMethodBuilder property of the stateMachine instance stateMachine.taskMethodBuilder = AsyncTaskMethodBuilder.Create(); // Set the currentState property of the stateMachine instance to -1 stateMachine.currentState = -1; // Start the stateMachine instance stateMachine.taskMethodBuilder.Start(ref stateMachine); // Return the Task property of the taskMethodBuilder return stateMachine.taskMethodBuilder.Task; } Beispiel einer generierten Zustandsmaschine ExampleStateMachine [CompilerGenerated] private sealed class ExampleStateMachine : IAsyncStateMachine { public int currentState; public AsyncTaskMethodBuilder taskMethodBuilder; private TaskAwaiter taskAwaiter; public int paramInt; private int localInt; void IAsyncStateMachine.MoveNext() { int num = currentState; try { TaskAwaiter awaiter3; TaskAwaiter awaiter2; TaskAwaiter awaiter; switch (num) { default: localInt = paramInt; // Call the first synchronous method SyncMethodA(); // Create a task awaiter for a delay of 1000 milliseconds awaiter3 = Task.Delay(1000).GetAwaiter(); // If the task is not completed, set the current state to 0 and store the awaiter if (!awaiter3.IsCompleted) { currentState = 0; taskAwaiter = awaiter3; // Store the current state machine ExampleStateMachine stateMachine = this; // Await the task and pass the state machine taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter3, ref stateMachine); return; } // If the task is completed, jump to the label after the first await goto Il_AfterFirstAwait; case 0: // Retrieve the awaiter from the taskAwaiter field awaiter3 = taskAwaiter; // Reset the taskAwaiter field taskAwaiter = default(TaskAwaiter); currentState = -1; // Jump to the label after the first await goto Il_AfterFirstAwait; case 1: // Retrieve the awaiter from the taskAwaiter field awaiter2 = taskAwaiter; // Reset the taskAwaiter field taskAwaiter = default(TaskAwaiter); currentState = -1; // Jump to the label after the second await goto Il_AfterSecondAwait; case 2: // Retrieve the awaiter from the taskAwaiter field awaiter = taskAwaiter; // Reset the taskAwaiter field taskAwaiter = default(TaskAwaiter); currentState = -1; break; Il_AfterFirstAwait: awaiter3.GetResult(); // Call the second synchronous method SyncMethodB(); // Create a task awaiter for a delay of 2000 milliseconds awaiter2 = Task.Delay(2000).GetAwaiter(); // If the task is not completed, set the current state to 1 and store the awaiter if (!awaiter2.IsCompleted) { currentState = 1; taskAwaiter = awaiter2; // Store the current state machine ExampleStateMachine stateMachine = this; // Await the task and pass the state machine taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine); return; } // If the task is completed, jump to the label after the second await goto Il_AfterSecondAwait; Il_AfterSecondAwait: // Get the result of the second awaiter awaiter2.GetResult(); // Call the SyncMethodC SyncMethodC(); // Create a new awaiter with a delay of 3000 milliseconds awaiter = Task.Delay(3000).GetAwaiter(); // If the awaiter is not completed, set the current state to 2 and store the awaiter if (!awaiter.IsCompleted) { currentState = 2; taskAwaiter = awaiter; // Set the stateMachine to this ExampleStateMachine stateMachine = this; // Await the task and pass the state machine taskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine); return; } break; } // Get the result of the awaiter awaiter.GetResult(); } catch (Exception exception) { currentState = -2; taskMethodBuilder.SetException(exception); return; } currentState = -2; taskMethodBuilder.SetResult(); } void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine) { /*...*/ } } SynchronizationContext Im Aufruf wird der aktuelle Synchronisationskontext abgerufen. ist ein Konzept in C#, das zur Darstellung eines Kontexts verwendet wird, der die Ausführung einer Reihe asynchroner Vorgänge steuert. Es wird verwendet, um die Ausführung von Code über mehrere Threads hinweg zu koordinieren und sicherzustellen, dass Code in einer bestimmten Reihenfolge ausgeführt wird. Der Hauptzweck von SynchronizationContext besteht darin, eine Möglichkeit zur Steuerung der Planung und Ausführung asynchroner Vorgänge in einer Multithread-Umgebung bereitzustellen. AwaitUnsafeOnCompleted SynchronizationContext SynchronizationContext In verschiedenen Umgebungen verfügt der über unterschiedliche Implementierungen. In .NET gibt es beispielsweise: SynchronizationContext : WPF System.Windows.Threading.DispatcherSynchronizationContext : WinForms System.Windows.Forms.WindowsFormsSynchronizationContext : WinRT System.Threading.WinRTSynchronizationContext : ASP.NET System.Web.AspNetSynchronizationContext verfügt außerdem über einen eigenen Synchronisierungskontext, , der es uns ermöglicht, asynchrone Vorgänge mit Bindung an die PlayerLoop-API zu verwenden. Das folgende Codebeispiel zeigt, wie man mit ein Objekt in jedem Frame dreht: Unity UnitySynchronizationContext Task.Yield() private async void Start() { while (true) { transform.Rotate(0, Time.deltaTime * 50, 0); await Task.Yield(); } } Ein weiteres Beispiel für die Verwendung von async/await in Unity zum Stellen einer Netzwerkanfrage: using UnityEngine; using System.Net.Http; using System.Threading.Tasks; public class NetworkRequestExample : MonoBehaviour { private async void Start() { string response = await GetDataFromAPI(); Debug.Log("Response from API: " + response); } private async Task GetDataFromAPI() { using (var client = new HttpClient()) { var response = await client.GetStringAsync("https://api.example.com/data"); return response; } } } Dank können wir Methoden (z. B. ) direkt nach Abschluss eines asynchronen Vorgangs sicher verwenden, da die Ausführung dieses Codes im Haupt-Unity-Thread fortgesetzt wird. UnitySynchronizationContext UnityEngine Debug.Log() TaskCompletionSource Mit dieser Klasse können Sie ein Objekt verwalten. Es wurde erstellt, um alte asynchrone Methoden an TAP anzupassen, ist aber auch sehr nützlich, wenn wir eine um einen lang andauernden Vorgang wickeln möchten, der bei einem bestimmten Ereignis auftritt. Task Task Im folgenden Beispiel wird das Objekt in 3 Sekunden nach dem Start abgeschlossen und wir erhalten das Ergebnis in der Methode: Task taskCompletionSource Update using System.Threading.Tasks; using UnityEngine; public class Example : MonoBehaviour { private TaskCompletionSource taskCompletionSource; private void Start() { // Create a new TaskCompletionSource taskCompletionSource = new TaskCompletionSource (); // Start a coroutine to wait 3 seconds // and then set the result of the TaskCompletionSource StartCoroutine(WaitAndComplete()); } private IEnumerator WaitAndComplete() { yield return new WaitForSeconds(3); // Set the result of the TaskCompletionSource taskCompletionSource.SetResult(10); } private async void Update() { // Await the result of the TaskCompletionSource int result = await taskCompletionSource.Task; // Log the result to the console Debug.Log("Result: " + result); } } Stornierungstoken In C# wird ein verwendet, um zu signalisieren, dass eine Aufgabe oder ein Vorgang abgebrochen werden soll. Das Token wird an die Aufgabe oder Operation übergeben, und der Code innerhalb der Aufgabe oder Operation kann das Token regelmäßig überprüfen, um festzustellen, ob die Aufgabe oder Operation gestoppt werden sollte. Dies ermöglicht einen sauberen und ordnungsgemäßen Abbruch einer Aufgabe oder eines Vorgangs, anstatt ihn einfach abrupt abzubrechen. Abbruchtoken Abbruchtokens werden häufig in Situationen verwendet, in denen eine lang laufende Aufgabe vom Benutzer abgebrochen werden kann oder wenn die Aufgabe nicht mehr benötigt wird, z. B. eine Schaltfläche zum Abbrechen in einer Benutzeroberfläche. Das Gesamtmuster ähnelt der Verwendung von . Zuerst wird eine erstellt, dann wird ihr an die asynchrone Operation übergeben: TaskCompletionSource CancellationTokenSource Token public class ExampleMonoBehaviour : MonoBehaviour { private CancellationTokenSource _cancellationTokenSource; private async void Start() { // Create a new CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource(); // Get the token from the CancellationTokenSource CancellationToken token = _cancellationTokenSource.Token; try { // Start a new Task and pass in the token await Task.Run(() => DoSomething(token), token); } catch (OperationCanceledException) { Debug.Log("Task was cancelled"); } } private void DoSomething(CancellationToken token) { for (int i = 0; i < 100; i++) { // Check if the token has been cancelled if (token.IsCancellationRequested) { // Return if the token has been cancelled return; } Debug.Log("Doing something..."); // Sleep for 1 second Thread.Sleep(1000); } } private void OnDestroy() { // Cancel the token when the object is destroyed _cancellationTokenSource.Cancel(); } } Wenn der Vorgang abgebrochen wird, wird eine ausgelöst und die Eigenschaft wird auf gesetzt. OperationCanceledException Task.IsCanceled true Neue asynchrone Funktionen in Unity 2022.2 Es ist wichtig zu beachten, dass von der .NET-Laufzeitumgebung und nicht von Unity verwaltet werden. Wenn das Objekt, das die Aufgabe ausführt, zerstört wird (oder wenn das Spiel den Spielmodus im Editor verlässt), wird die Aufgabe weiterhin wie von Unity ausgeführt Es gibt keine Möglichkeit, es abzubrechen. Task Sie müssen immer mit dem entsprechenden begleiten. Dies führt zu einer gewissen Redundanz des Codes, und in Unity 2022.2 wurden integrierte Token auf der Ebene und der gesamten angezeigt. await Task CancellationToken MonoBehaviour Application Sehen wir uns an, wie sich das vorherige Beispiel ändert, wenn das des Objekts verwendet wird: destroyCancellationToken MonoBehaviour using System.Threading; using System.Threading.Tasks; using UnityEngine; public class ExampleMonoBehaviour : MonoBehaviour { private async void Start() { // Get the cancellation token from the MonoBehaviour CancellationToken token = this.destroyCancellationToken; try { // Start a new Task and pass in the token await Task.Run(() => DoSomething(token), token); } catch (OperationCanceledException) { Debug.Log("Task was cancelled"); } } private void DoSomething(CancellationToken token) { for (int i = 0; i < 100; i++) { // Check if the token has been cancelled if (token.IsCancellationRequested) { // Return if the token has been cancelled return; } Debug.Log("Doing something..."); // Sleep for 1 second Thread.Sleep(1000); } } } Wir müssen nicht mehr manuell eine erstellen und die Aufgabe in der Methode abschließen. Für Aufgaben, die nicht mit einem bestimmten verknüpft sind, können wir verwenden. Dadurch wird die Aufgabe beim Verlassen des Wiedergabemodus (im Editor) oder beim Beenden der Anwendung beendet. CancellationTokenSource OnDestroy MonoBehaviour UnityEngine.Application.exitCancellationToken UniTask Trotz der Benutzerfreundlichkeit und der von .NET Tasks bereitgestellten Funktionen weisen sie bei der Verwendung in Unity erhebliche Nachteile auf: sind zu umständlich und verursachen viele Zuordnungen. Task ist nicht dem Unity-Threading (Single-Thread) zugeordnet. Task Die Bibliothek umgeht diese Einschränkungen, ohne Threads oder zu verwenden. Das Fehlen von Zuordnungen wird durch die Verwendung des strukturbasierten Typs erreicht. UniTask- SynchronizationContext UniTask UniTask erfordert die .NET 4.x-Skriptlaufzeitversion, wobei Unity 2018.4.13f1 die offiziell niedrigste unterstützte Version ist. Sie können auch alle mit Erweiterungsmethoden in konvertieren: AsyncOperations UnitTask using UnityEngine; using UniTask; public class AssetLoader : MonoBehaviour { public async void LoadAsset(string assetName) { var loadRequest = Resources.LoadAsync (assetName); await loadRequest.AsUniTask(); var asset = loadRequest.asset as GameObject; if (asset != null) { // Do something with the loaded asset } } } In diesem Beispiel verwendet die Methode , um ein Asset asynchron zu laden. Die Methode wird dann verwendet, um die von zurückgegebene in eine umzuwandeln, die abgewartet werden kann. LoadAsset Resources.LoadAsync AsUniTask LoadAsync AsyncOperation UniTask Wie zuvor können Sie mit und jede beliebige Kombination der Ausführungsreihenfolge organisieren: UniTask.WhenAll UniTask.WhenAny using System.Threading; using Cysharp.Threading.Tasks; using UnityEngine; public class Example : MonoBehaviour { private async void Start() { // Start two Tasks and wait for both to complete await UniTask.WhenAll(Task1(), Task2()); // Start two Tasks and wait for one to complete await UniTask.WhenAny(Task1(), Task2()); } private async UniTask Task1() { // Do something } private async UniTask Task2() { // Do something } } In UniTask gibt es eine weitere Implementierung von namens , die zur Erzielung einer besseren Leistung als Ersatz für verwendet werden kann. SynchronizationContext UniTaskSynchronizationContext UnitySynchronizationContext Erwartete API In der ersten Alpha-Version von Unity 2023.1 wurde die Klasse eingeführt. Awaitable-Coroutinen sind asynchrone/await-kompatible aufgabenähnliche Typen, die für die Ausführung in Unity entwickelt wurden. Im Gegensatz zu .NET-Aufgaben werden sie von der Engine und nicht von der Laufzeit verwaltet. Awaitable private async Awaitable DoSomethingAsync() { // awaiting built-in events await Awaitable.EndOfFrameAsync(); await Awaitable.WaitForSecondsAsync(); // awaiting .NET Tasks await Task.Delay(2000, destroyCancellationToken); await Task.Yield(); // awaiting AsyncOperations await SceneManager.LoadSceneAsync("path/to/scene.unity"); // ... } Sie können erwartet und als Rückgabetyp einer asynchronen Methode verwendet werden. Im Vergleich zu sind sie weniger ausgefeilt, nutzen aber leistungssteigernde Abkürzungen, die auf Unity-spezifischen Annahmen basieren. System.Threading.Tasks Hier sind die Hauptunterschiede im Vergleich zu .NET-Aufgaben: Auf das Objekt kann nur einmal gewartet werden; Es kann nicht von mehreren asynchronen Funktionen erwartet werden. Awaitable wird bis zum Abschluss nicht blockiert. Der Aufruf vor Abschluss des Vorgangs ist ein undefiniertes Verhalten. Awaiter.GetResults() Erfassen Sie niemals einen . Aus Sicherheitsgründen erfassen .NET-Aufgaben beim Warten Ausführungskontexte, um Identitätswechselkontexte über asynchrone Aufrufe hinweg weiterzugeben. ExecutionContext Erfassen Sie niemals . Coroutine-Fortsetzungen werden synchron vom Code ausgeführt, der die Vervollständigung auslöst. In den meisten Fällen erfolgt dies über den Unity-Hauptrechner. SynchronizationContext Awaitables sind gepoolte Objekte, um übermäßige Zuweisungen zu verhindern. Dabei handelt es sich um Referenztypen, sodass sie über verschiedene Stapel hinweg referenziert, effizient kopiert usw. werden können. Der wurde verbessert, um -Grenzprüfungen in typischen Get/Release-Sequenzen zu vermeiden, die von asynchronen Zustandsmaschinen generiert werden. ObjectPool Stack Um das Ergebnis eines längeren Vorgangs zu erhalten, können Sie den Typ verwenden. Sie können den Abschluss eines mithilfe von und verwalten ähnlich wie bei : Awaitable Awaitable AwaitableCompletionSource AwaitableCompletionSource , TaskCompletitionSource using UnityEngine; using Cysharp.Threading.Tasks; public class ExampleBehaviour : MonoBehaviour { private AwaitableCompletionSource _completionSource; private async void Start() { // Create a new AwaitableCompletionSource _completionSource = new AwaitableCompletionSource (); // Start a coroutine to wait 3 seconds // and then set the result of the AwaitableCompletionSource StartCoroutine(WaitAndComplete()); // Await the result of the AwaitableCompletionSource bool result = await _completionSource.Awaitable; // Log the result to the console Debug.Log("Result: " + result); } private IEnumerator WaitAndComplete() { yield return new WaitForSeconds(3); // Set the result of the AwaitableCompletionSource _completionSource.SetResult(true); } } Manchmal sind umfangreiche Berechnungen erforderlich, die zum Einfrieren des Spiels führen können. Hierfür ist es besser, die Awaitable-Methoden zu verwenden: und . Sie ermöglichen es Ihnen, den Hauptthread zu verlassen und zu ihm zurückzukehren. BackgroundThreadAsync() MainThreadAsync() private async Awaitable DoCalculationsAsync() { // Awaiting execution on a ThreadPool background thread. await Awaitable.BackgroundThreadAsync(); var result = PerformSomeHeavyCalculations(); // Awaiting execution on the Unity main thread. await Awaitable.MainThreadAsync(); // Using the result in main thread Debug.Log(result); } Auf diese Weise beseitigen Awaitables die Nachteile der Verwendung von .NET-Aufgaben und ermöglichen außerdem das Warten auf PlayerLoop-Ereignisse und AsyncOperations. Abschluss Wie wir sehen können, gibt es mit der Entwicklung von Unity immer mehr Tools zum Organisieren asynchroner Vorgänge: Einheit Coroutinen Versprechen .NET-Aufgaben UniTask Integrierte Stornierungstoken Erwartete API 5.6 ✅ ✅ 2017.1 ✅ ✅ ✅ 2018.4 ✅ ✅ ✅ ✅ 2022.2 ✅ ✅ ✅ ✅ ✅ 2023.1 ✅ ✅ ✅ ✅ ✅ ✅ Wir haben alle wichtigen Möglichkeiten der asynchronen Programmierung in Unity betrachtet. Abhängig von der Komplexität Ihrer Aufgabe und der von Ihnen verwendeten Unity-Version können Sie eine breite Palette von Technologien von Coroutines und Promises bis hin zu Tasks und Awaitables nutzen, um ein reibungsloses und nahtloses Gameplay in Ihren Spielen zu gewährleisten. Vielen Dank fürs Lesen und wir freuen uns auf Ihre nächsten Meisterwerke.