C# API Unterschiede zu GDScript¶

Dies ist eine (unvollständige) Liste von API Unterschieden zwischen C# und GDScript.

Allgemeine Unterschiede¶

Wie im C# Grundlagen erklärt, benutzt C# generell PascalCase anstatt von snake_case, welches in GDScript und C++ benutzt wird.

Globaler Bereich¶

Globale Funktionen und einige Konstanten mussten in Klassen verschoben werden, da C# es nicht erlaubt sie in Namespaces zu deklarieren. Die meisten globalen Konstanten wurden in ihre eigenen Aufzählungen verschoben.

Konstanten¶

Globale Konstanten wurden in ihre eigenen Aufzählungen verschoben. Zum Beispiel wurden ERR_* Konstanten in die Error Aufzählung verschoben.

Sonderfälle:

GDScript	C#
`SPKEY`	`GD.SpKey`
`TYPE_*`	`Variant.Type` Aufzählung
`OP_*`	`Variant.Operator` Aufzählung

Mathematische Funktionen¶

Globale Mathefunktionen wie abs, acos, asin, atan und atan2 liegen unter Mathf als Abs, Acos, Asin, Atan und Atan2. Die PI Konstante findet man unter Mathf.Pi.

Zufallsfunktionen¶

Globale Zufallsfunktionen wie rand_range und rand_seed liegen unter GD. Beispiel: GD.RandRange und GD.RandSeed.

Weitere Funktionen¶

Viele andere globale Funktionen wie print und var2str liegen unter GD. Beispiel: GD.Print und GD.Var2Str.

Ausnahmen:

GDScript	C#
`weakref(obj)`	`Object.WeakRef(obj)`
`is_instance_valid(obj)`	`Object.IsInstanceValid(obj)`

Tipps¶

Manchmal kann es nützlich sein, die Direktive using static zu verwenden. Diese Anweisung ermöglicht den Zugriff auf die Mitglieder und verschachtelten Typen einer Klasse, ohne den Klassennamen anzugeben.

Beispiel:

using static Godot.GD;

public class Test
{
    static Test()
    {
        Print("Hello"); // Instead of GD.Print("Hello");
    }
}

Exportiere Schlüsselwort¶

Verwenden Sie die Eigenschaft [Export] anstelle des GDScript-Schlüsselworts export. Diese Eigenschaft kann auch mit diesen Parametern optional versehen werden: PropertyHint und hintString. Standardwerte können durch Zuweisen eines Werts festgelegt werden.

Beispiel:

using Godot;

public class MyNode : Node
{
    [Export]
    private NodePath _nodePath;

    [Export]
    private string _name = "default";

    [Export(PropertyHint.Range, "0,100000,1000,or_greater")]
    private int _income;

    [Export(PropertyHint.File, "*.png,*.jpg")]
    private string _icon;
}

Signal Schlüsselwörter¶

Verwenden Sie die Eigenschaft [Signal] um ein Signal anstelle des GDScript-Schlüsselworts signal zu deklarieren. Diese Eigenschaft sollte für ein delegate verwendet werden, dessen Namenssignatur zur Definition des Signals verwendet wird.

[Signal]
delegate void MySignal(string willSendsAString);

Siehe auch: C# Signale.

onready Schlüsselwort¶

GDScript hat die Möglichkeit, die Initialisierung einer Member-Variable aufzuschieben, bis die Ready-Funktion mit onready aufgerufen wird (vgl. onready Schlüsselwort). Zum Beispiel:

onready var my_label = get_node("MyLabel")

C# verfügt jedoch nicht über diese Fähigkeit. Um den gleichen Effekt zu erzielen, muss das Folgende getan werden.

private Label _myLabel;

public override void _Ready()
{
    _myLabel = GetNode<Label>("MyLabel");
}

Singletons¶

Singletons sind als statische Klassen verfügbar, anstatt das Singleton-Muster zu verwenden. Dies dient dazu den Code weniger ausführlich zu machen als bei einer Instance-Eigenschaft.

Beispiel:

Input.IsActionPressed("ui_down")

In einigen sehr seltenen Fällen reicht dies jedoch nicht aus. Beispielsweise möchten Sie vielleicht auf ein Mitglied aus der Basisklasse Godot.Object zugreifen, z.B. Connect. Für solche Anwendungsfälle stellen wir eine statische Eigenschaft mit dem Namen Singleton bereit, die die Singleton-Instanz zurückgibt. Der Typ dieser Instanz ist Godot.Object.

Beispiel:

Input.Singleton.Connect("joy_connection_changed", this, nameof(Input_JoyConnectionChanged));

Zeichenkette¶

Verwenden Sie System.String (string). Die meisten String-Methoden von Godot werden von der Klasse StringExtensions als Erweiterungsmethoden bereitgestellt.

Beispiel:

string upper = "I LIKE SALAD FORKS";
string lower = upper.ToLower();

Es gibt allerdings ein paar Unterschiede:

erase: Zeichenfolgen sind in C# unveränderlich, daher können wir die an die Erweiterungsmethode übergebene Zeichenfolge nicht ändern. Aus diesem Grund wurde Erase als Erweiterungsmethode von StringBuilder anstelle von string hinzugefügt. Alternativ können Sie string.Remove verwenden.
IsSubsequenceOf/IsSubsequenceOfi: Es wird eine zusätzliche Methode bereitgestellt, bei der es sich um eine Überladung von IsSubsequenceOf handelt, mit der Sie die Groß- und Kleinschreibung explizit angeben können:

str.IsSubsequenceOf("ok"); // Case sensitive
str.IsSubsequenceOf("ok", true); // Case sensitive
str.IsSubsequenceOfi("ok"); // Case insensitive
str.IsSubsequenceOf("ok", false); // Case insensitive

Match/Matchn/ExprMatch: Neben Match und Matchn wird eine zusätzliche Methode bereitgestellt, mit der Sie die Groß- und Kleinschreibung explizit angeben können:

str.Match("*.txt"); // Case sensitive
str.ExprMatch("*.txt", true); // Case sensitive
str.Matchn("*.txt"); // Case insensitive
str.ExprMatch("*.txt", false); // Case insensitive

Basis¶

Strukturen können in C# keine parameterlosen Konstruktoren haben. Daher initialisiert new Basis() alle primitiven Mitglieder auf ihren Standardwert. Verwenden Sie Basis.Identity anstelle von Basis() in GDScript und C++.

Die folgende Methode wurde in eine Eigenschaft mit einem neuen Namen konvertiert:

GDScript	C#
`get_scale()`	`Scale`

Transform2D¶

Strukturen können in C# keine parameterlosen Konstruktoren haben. Daher initialisiert new Transform2D() alle primitiven Elemente auf ihren Standardwert. Bitte verwenden Sie Transform2D.Identity anstelle von Transform2D() in GDScript und C++.

Die folgenden Methoden wurden in Eigenschaften konvertiert, deren jeweilige Namen geändert wurden:

GDScript	C#
`get_rotation()`	`Drehung`
`get_scale()`	`Scale`

Ebene¶

Die folgende Methode wurde in eine Eigenschaft mit einem etwas anderen Namen konvertiert:

GDScript	C#
`center()`	`Center`

Rect2¶

Das folgende Feld wurde in eine Eigenschaft mit einem etwas anderen Namen konvertiert:

GDScript	C#
`end`	`End`

Die folgende Methode wurde in eine Eigenschaft mit einem neuen Namen konvertiert:

GDScript	C#
`get_area()`	`Area`

Quat¶

Strukturen können in C# keine parameterlosen Konstruktoren haben. Daher initialisiert new Quat() alle primitiven Mitglieder auf ihren Standardwert. Bitte verwenden Sie Quat.Identity anstelle von Quat() in GDScript und C++.

Die folgenden Methoden wurden in eine Eigenschaft mit einem anderen Namen konvertiert:

GDScript	C#
`length()`	`Length`
`length_squared()`	`LengthSquared`

Array¶

Das ist vorübergehend. PoolArrays benötigen ihre eigenen Typen um sie wie gewünscht zu verwenden.

GDScript	C#
`Array`	`Godot.Collections.Array`
`PoolIntArray`	`int[]`
`PoolByteArray`	`byte[]`
`PoolFloatArray`	`float[]`
`PoolStringArray`	`String[]`
`PoolColorArray`	`Color[]`
`PoolVector2Array`	`Vector2[]`
`PoolVector3Array`	`Vector3[]`

Godot.Collections.Array<T> ist eine typsichere Hülle um Godot.Collections.Array. Verwenden Sie den Konstruktor Godot.Collections.Array<T>(Godot.Collections.Array) um eine zu erstellen.

Dictionary (Wörterbuch)¶

Nutze Godot.Collections.Dictionary.

Godot.Collections.Dictionary<T> ist eine typsichere Hülle um Godot.Collections.Dictionary. Verwenden Sie den Konstruktor Godot.Collections.Dictionary<T>(Godot.Collections.Dictionary) um eine zu erstellen.

Variante¶

System.Object (object) wird genutzt anstelle von Variant.

Kommunikation mit anderen Skriptsprachen¶

Dies wird detailliert beschrieben in Cross-Language-Scripting.

Ertrag (zur Diskussion)¶

Etwas Ähnliches wie GDScript's yield mit einem einzigen Parameter kann mit C#'s yield Schlüsselwort erreicht werden.

Das Gleiche wie yield für Signale kann mit async/await und ``Godot.Object.ToSignal``erreicht werden.

Beispiel:

await ToSignal(timer, "timeout");
GD.Print("After timeout");

Andere Unterschiede¶

preload wie es in GDScript funktioniert, ist in C# nicht verfügbar. Verwenden Sie stattdessen GD.Load oder ResourceLoader.Load.

Andere Unterschiede:

GDScript	C#
`Color8`	`Color.Color8`
`ist_inf`	`float.IsInfinity`
`is_nan`	`float.IsNaN`
`dict2inst`	TODO
`instant2dict`	TODO