https://github.com/ellpeck/coroutine
A simple implementation of Unity's Coroutines to be used for any C# project
https://github.com/ellpeck/coroutine
coroutines csharp-library netcore netframework unity-coroutines
Last synced: 10 months ago
JSON representation
A simple implementation of Unity's Coroutines to be used for any C# project
- Host: GitHub
- URL: https://github.com/ellpeck/coroutine
- Owner: Ellpeck
- License: mit
- Created: 2019-06-22T15:20:49.000Z (over 6 years ago)
- Default Branch: main
- Last Pushed: 2023-02-23T18:11:40.000Z (almost 3 years ago)
- Last Synced: 2025-03-24T01:11:51.882Z (10 months ago)
- Topics: coroutines, csharp-library, netcore, netframework, unity-coroutines
- Language: C#
- Homepage: https://www.nuget.org/packages/Coroutine
- Size: 71.3 KB
- Stars: 39
- Watchers: 4
- Forks: 4
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Funding: .github/FUNDING.yml
- License: LICENSE.md
Awesome Lists containing this project
README
**Coroutine** is a simple implementation of Unity's Coroutines to be used for any C# project
# Features
Coroutine adds the ability to run coroutines. Coroutines are methods that run in parallel to the rest of the application through the use of an `Enumerator`. This allows for the coroutine to pause execution using the `yield return` statement.
There are two predefined ways to pause a coroutine:
- Waiting for a certain amount of seconds to have passed
- Waiting for a certain custom event to occur
Additionally, Coroutine provides the following features:
- Creation of custom events to wait for
- No multi-threading, which allows for any kind of process to be executed in a coroutine, including rendering
- Thread-safety, which allows for coroutines to be started from different threads
# How to Use
## Setting up the CoroutineHandler
The `CoroutineHandler` is the place where coroutines get executed. For this to occur, the `Tick` method needs to be called continuously. The `Tick` method takes a single parameter which represents the amount of time since the last time it was called. It can either be called in your application's existing update loop or as follows.
```cs
var lastTime = DateTime.Now;
while (true) {
var currTime = DateTime.Now;
CoroutineHandler.Tick(currTime - lastTime);
lastTime = currTime;
Thread.Sleep(1);
}
```
## Creating a Coroutine
To create a coroutine, simply create a method with the return type `IEnumerator`. Then, you can use `yield return` to cause the coroutine to wait at any point:
```cs
private static IEnumerator WaitSeconds() {
Console.WriteLine("First thing " + DateTime.Now);
yield return new Wait(1);
Console.WriteLine("After 1 second " + DateTime.Now);
yield return new Wait(5);
Console.WriteLine("After 5 seconds " + DateTime.Now);
yield return new Wait(10);
Console.WriteLine("After 10 seconds " + DateTime.Now);
}
```
## Starting a Coroutine
To start a coroutine, simply call `Start`:
```cs
CoroutineHandler.Start(WaitSeconds());
```
## Using Events
To use an event, an `Event` instance first needs to be created. When not overriding any equality operators, only a single instance of each event should be used.
```cs
private static readonly Event TestEvent = new Event();
```
Waiting for an event in a coroutine works as follows:
```cs
private static IEnumerator WaitForTestEvent() {
yield return new Wait(TestEvent);
Console.WriteLine("Test event received");
}
```
Of course, having time-based waits and event-based waits in the same coroutine is also supported.
To actually cause the event to be raised, causing all currently waiting coroutines to be continued, simply call `RaiseEvent`:
```cs
CoroutineHandler.RaiseEvent(TestEvent);
```
## Additional Examples
For additional examples, take a look at the [Example class](https://github.com/Ellpeck/Coroutine/blob/main/Example/Example.cs).