C# compréhension sur deux écritures

Version imprimable

Bonjour,
Je ne connais pas le C# mais j'essai d'utiliser un programme en C# pour le réécrire en Tcl/Tk.
J'ai ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public Vector3d Row0; public Vector3d Row1; public Vector3d Row2; public Matrix3d ClearScale() { var m = this; m.Row0 = m.Row0.Normalized(); m.Row1 = m.Row1.Normalized(); m.Row2 = m.Row2.Normalized(); return m; }
Puis je l'écrire de cette façon :
Code:

1 2 3 4 5 6 7 8 public Matrix3d ClearScale() { var m = this; Row0 = Row0.Normalized(); Row1 = Row1.Normalized(); Row2 = Row2.Normalized(); return m; }
Ou pas du tout... Je ne comprends pas pourquoi l'auteur la écrit de cette façon là ? Il y a probablement une raison, mais je ne vois pas laquelle
Merci

10/01/2021, 13h45
StringBuilder
Je ne comprends pas du tout le pourquoi du comment du "var m = this;"

Ensuite, les deux écritures me semble passablement identiques, sauf éventuellement peut-être dans certains cas obscurs d'héritage, et encore, je ne vois pas trop...

Aussi, je ne vois franchement pas l'intérêt de faire un "return this;".
Qu'on fasse un "return this.Clone();" pourquoi pas... mais du moment qu'on a modifié l'instance, autant continuer à utiliser l'instance, pas une nouvelle référence à la même instance !

Dans tous les cas, je réécrirais :
Code:

1 2 3 4 5 6 7 public void ClearScale() { Row0 = Row0.Normalized(); Row1 = Row1.Normalized(); Row2 = Row2.Normalized(); }
Et depuis l'appelant :
Code:

1 2 3 4 5 6 Matrix3d matrice = new Matrix3d(); matrice.ClearScale(); // Puis on continue d'utiliser matrice au lieu d'une autre référence...
10/01/2021, 14h21
François DORIN

Je pense que l'auteur initial vient du monde javascript, où assigner this a une variable locale est courante, notamment avec les closures !

En C# par contre, il n'y a aucun différence a appeler l'un ou l'autre. Introduire une variable supplémentaire qui contient this me parait même contreproductif !

Par contre, le return this; a un intérêt, puisqu'il permet de chainer les méthodes : matrix.ClearScale().AddTranslation(...).AddRotation(...)...
10/01/2021, 17h27
StringBuilder

Citation:

Envoyé par François DORIN

Par contre, le return this; a un intérêt, puisqu'il permet de chainer les méthodes : matrix.ClearScale().AddTranslation(...).AddRotation(...)...

Ah oui, c'est vrai, au temps pour moi :)

Vu que je trouve cette syntaxe franchement pas jolie, je ne m'en sers jamais.
10/01/2021, 22h11
Mat.M

bonsoir,
il vaut mieux éviter d'utiliser une variable de type var et donc il faut la forcer à un type bien défini.
Je sais qu'en Javascript on est contraint d'utiliser des "variants" mais en C# il vaut mieux utiliser un type plus correspondant.
Parce que lorsqu'on définit une variable de type var le source compilé en Intermediate Language doit faire certainement beaucoup d'allocations.
Pour une variable ce n'est pas important pour tout un tableau de variable ça peut nuire aux performances
11/01/2021, 19h17
Mkn31

Merci à tous de vos commentaires et de vos remarques. Je continue...

Le comportement entre les 2 syntaxes est différent si Matrix3d est une struct:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
    class Program
    {
        static void Main()
        {
            var sample = new Sample();
            sample.Value = 1;
            Console.WriteLine(sample.Value); // 1
 
            var sample1 = sample.Update();
            Console.WriteLine(sample.Value);  // 2
            Console.WriteLine(sample1.Value); // 2
 
            var sample2 = sample.Update2();
            Console.WriteLine(sample.Value);  // 2
            Console.WriteLine(sample2.Value); // 3
        }
    }
 
    struct Sample
    {
        public int Value { get; set; }
 
        public Sample Update()
        {
            Value = 2;
            return this;
        }
 
        public Sample Update2()
        {
            var a = this;
            a.Value = 3;
            return a;
        }
    }