Différences de l'API C# par rapport à GDScript¶

Il s'agit d'une liste (incomplète) des différences d'API entre C# et GDScript.

Différences générales¶

Comme expliqué dans le Les bases du C#, C# utilise généralement PascalCase à la place du snake_case utilisé dans GDScript et C++.

Portée globale¶

Les fonctions globales et certaines constantes ont dû être déplacées dans des classes, puisque C# ne permet pas de les déclarer dans les espaces de noms. La plupart des constantes globales ont été déplacées dans leurs propres énumérations.

Constantes¶

Les constantes globales ont été déplacées dans leurs propres énumérations. Par exemple, les constantes ERR_* ont été déplacées dans l'énumération Error.

Cas particuliers :

GDScript	C#
`SPKEY`	`GD.SpKey`
`TYPE_*`	`Variant.Type` enum
`OP_*`	`Variant.Operator` enum

Fonctions mathématiques¶

Les fonctions mathématiques telles que abs, acos, asin, atan et atan2 sont situées dans Mathf : Abs, Acos, Asin, Atan and Atan2. La constante PI peut être trouvée dans Mathf.PI.

Fonctions aléatoires¶

Les fonctions globales aléatoires, comme rand_range et rand_seed, se trouvent sous GD. Exemple : GD.RandRange et GD.RandSeed.

Autres fonctions¶

Beaucoup d'autres fonctions globales comme print et var2str se trouvent sous GD. Exemple : GD.Print et GD.Var2Str.

Exceptions :

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

Conseils¶

Parfois, il peut être utile d'utiliser la directive using static. Cette directive permet d'accéder aux membres et aux types imbriqués d'une classe sans spécifier le nom de la classe.

Exemple :

using static Godot.GD;

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

Mot-clé d'exportation¶

Utilisez l'attribut [Export] au lieu du mot-clé GDScript export. Cet attribut peut aussi être complété de paramètres optionnels PropertyHint et hintString. La valeur par défaut peut être réglée en assignant une valeur.

Exemple :

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;
}

Mot-clé de signal¶

Utilisez l'attribut [Signal] pour déclarer un signal au lieu du mot-clé GDScript signal. Cet attribut doit être utilisé sur un delegate, dont la signature de nom sera utilisée pour définir le signal.

[Signal]
delegate void MySignal(string willSendsAString);

Voir aussi : Signaux C#.

Mot-clé onready¶

GDScript a la possibilité de différer l'initialisation d'une variable membre jusqu'à ce que la fonction ready soit appelée avec onready (cf. Mot-clé onready). Par exemple :

onready var my_label = get_node("MyLabel")

Cependant, le C# ne dispose pas de cette capacité. Pour obtenir le même effet, vous devez procéder comme suit.

private Label _myLabel;

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

Singletons¶

Les singletons fournissent des méthodes statiques plutôt que d'utiliser le patron singleton. C'est pour rendre le code moins verbeux qu'il ne le serait avec une propriété Instance.

Exemple :

Input.IsActionPressed("ui_down")

Cependant, dans certains cas très rares, ce n'est pas suffisant. Par exemple, vous pouvez accéder à un membre de la classe de base Godot.Object, comme Connect. Pour l'utilisation de tels cas, nous fournissons une propriété statique nommée Singleton qui retourne l'instance du singleton. Le type de cette instance est Godot.Object.

Exemple :

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

Chaîne de caractères¶

Utilisez System.String (string). La plupart des méthodes String de Godot sont fournies par la classe StringExtensions comme méthodes d'extension.

Exemple :

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

Il y a cependant quelques différences :

erase : les chaînes de caractères sont immuables en C#, nous ne pouvons donc pas modifier la chaîne passée à la méthode d'extension. Pour cette raison, Erase a été ajoutée comme méthode d'extension de StringBuilder au lieu de string. Alternativement, vous pouvez utiliser string.Remove.
IsSubsequenceOf/IsSubsequenceOfi : Une méthode supplémentaire est fournie, qui est une surcharge de IsSubsequenceOf permettant de spécifier explicitement la sensibilité à la casse :

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 : Une méthode supplémentaire est fournie en plus de Match et Matchn, qui permet de spécifier explicitement la sensibilité à la casse :

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

Basis¶

Les Structs ne peuvent pas avoir de constructeurs sans paramètres en C#, c'est pourquoi new Basis() initialise tous les membres primitifs à leur valeur par défaut. Utilisez Basis.Identity pour l'équivalent de Basis() en GDScript et C++.

La méthode suivante a été convertie en une propriété avec un nom différent :

GDScript	C#
`get_scale()`	`Scale`

Transform2D¶

Les Structs ne peuvent pas avoir de constructeurs sans paramètres en C#, c'est pourquoi new Transform2D() initialise tous les membres primitifs à leur valeur par défaut. Veuillez utiliser Transform2D.Identity pour l'équivalent de Transform2D() en GDScript et C++.

Les méthodes suivantes ont été converties en propriétés avec leurs noms respectifs modifiés :

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

Plan¶

La méthode suivante a été convertie en une propriété avec un nom légèrement différent :

GDScript	C#
`center()`	`Center`

Rect2¶

Le champ suivant a été converti en une propriété avec un nom légèrement différent :

GDScript	C#
`end`	`End`

La méthode suivante a été convertie en une propriété avec un nom différent :

GDScript	C#
`get_area()`	`Area`

Quat¶

Les Structs ne peuvent pas avoir de constructeurs sans paramètres en C#, c'est pourquoi new Quat() initialise tous les membres primitifs à leur valeur par défaut. Veuillez utiliser Quat.Identity pour l'équivalent de Quat() en GDScript et C++.

Les méthodes suivantes ont été converties en une propriété avec un nom différent :

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

Tableau¶

C'est temporaire. Les PoolArrays auront besoin de leurs propres types pour être utilisés de la manière à laquelle ils sont destinés.

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

Godot.Collections.Array<T> est une encapsule de type sécurisé autour de Godot.Collections.Array. Utilisez le constructeur Godot.Collections.Array<T>(Godot.Array) pour en créer une.

Dictionnaire¶

Utilisez Godot.Collections.Dictionary.

Godot.Collections.Dictionary <T> est une encapsule de type sécurisé Godot.Collections.Dictionary. Utilisez le constructeur Godot.Collections.Dictionary <T>(Godot.Dictionary) pour en créer un.

Variant¶

System.Object (object) est utilisé à la place de Variant.

Communiquer avec d'autres langages de script¶

Ceci est expliqué en détail dans Scripting multi-langage.

Yield¶

Quelque chose de similaire à yield de GDScript avec un seul paramètre peut être réalisé avec le mot-clé yield de C#.

L'équivalent de yield sur un signal peut être obtenu avec async/await et Godot.Object.ToSignal.

Exemple :

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

Autres différences¶

preload, comme il fonctionne en GDScript, n'est pas disponible en C#. Utilisez GD.Load ou ResourceLoader.Load à la place.

Autres différences :

GDScript	C#
`Color8`	`Color.Color8`
`is_inf`	`float.IsInfinity`
`is_nan`	`float.IsNaN`
`dict2inst`	TODO
`inst2dict`	TODO