Discussion :

[nitteo]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private void Fonction()
        {
            BitUnion union = new BitUnion();
            int index = 0;
            int num2 = 0;
            for (int i = 0; i < 100; i++) //boucle de 0 a 99
            {
                index = this.nMap[i] / 0x20; //met dans index le quotien
                num2 = this.nMap[i] % 0x20; // met dans num2 le modulo
                if ((this.m_bitunion.m_bits[index] & ((uint)(((long)1L) << num2))) != 0)
                {
                    index = i / 0x20;
                    num2 = i % 0x20;
                    union.m_bits[index] |= (uint)(((long)1L) << num2);
                }
                else
                {
                    index = i / 0x20;
                    num2 = i % 0x20;
                    union.m_bits[index] &= ~((uint)(((long)1L) << num2));
                }
            }
            this.m_bitunion = union;
        }

-----------------
Sachant que nMap est un tableau de 100 entiers mélangés
que la classe BitUnion contient une variable m_bit.[] de type entier et de taille 4
exemple:
m_bits.[0] = 0x00000022
m_bits.[1] = 0x00000042
m_bits.[2] = 0x00000542
m_bits.[3] = 0x00006544

Est ce qu'il fait un ou logique et un décalage à gauche ou l'inverse ?
une inversion de bit avant le ET logique ?

[Chubyone]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
private void Fonction()
{
 
BitUnion union = new BitUnion();
int index = 0;
int num2 = 0;
 
for (int i = 0; i < 100; i++) //boucle de 0 a 99
{
 
 index = this.nMap[i] / 0x20; //met dans index le quotien
 num2 = this.nMap[i] % 0x20; // met dans num2 le modulo
 
if ( (this.m_bitunion.m_bits[index] & ((uint)(((long)1L) << num2))) != 0 )
 {
   index = i / 0x20;
   num2 = i % 0x20;
   union.m_bits[index] |= (uint)(((long)1L) << num2);
 }
 else
 {
   index = i / 0x20;
   num2 = i % 0x20;
   union.m_bits[index] &= ~((uint)(((long)1L) << num2));
 }
}
this.m_bitunion = union;
}

Et il n'est pas optionnel de dire Bonjour et Merci...

Sérieux quel boulet celui qui a pondu cette fonction, j'adore les commentaires : "/boucle de 0 a 99" Suuuuuuuuuper!

Une des philos en C# est de se passer de Commentaires. Pourquoi? Parce que si on a besoin de commenter c'est que le code est trop compliqué. S'il est trop compliqué, il y a beaucoup de chance pour qu'il soit instable... Et même s'il est compliqué pour des besoins de performances incroyable, on commente chaque lignes précisément... -_-

[nitteo]

Bonjour,

cette fonction est extraite d'un logiciel pas codé par moi
les commentaires c'est pour aider, LOL.

voudrais juste savoir ce qu'elle fait cette fonction pour faire l'inverse
voila, merci d'avance aux pro du C# .

[Guulh]

Une des philos en C# est de se passer de Commentaires. Pourquoi? Parce que si on a besoin de commenter c'est que le code est trop compliqué. S'il est trop compliqué, il y a beaucoup de chance pour qu'il soit instable... Et même s'il est compliqué pour des besoins de performances incroyable, on commente chaque lignes précisément... -_-

Justement, C# (et pas DotNet) a un système de commentaires XML sur lequel se base Intellisense pour afficher une aide contextuelle sur chaque objet / fonction / enum... C'est super bien foutu quand même, la MSDN est basée là-dessus Après, sûr que des commentaires style "on boucle de 0 à 99" sont à jeter.

[ced600]

Envoyé par Chubyone
Une des philos en C# est de se passer de Commentaires. Pourquoi? Parce que si on a besoin de commenter c'est que le code est trop compliqué. S'il est trop compliqué, il y a beaucoup de chance pour qu'il soit instable... Et même s'il est compliqué pour des besoins de performances incroyable, on commente chaque lignes précisément... -_-

Justement, C# (et pas DotNet) a un système de commentaires XML sur lequel se base Intellisense pour afficher une aide contextuelle sur chaque objet / fonction / enum... C'est super bien foutu quand même, la MSDN est basée là-dessus Après, sûr que des commentaires style "on boucle de 0 à 99" sont à jeter.

Les commentaires sont INDISPENSABLES, mais il est inutile d'écrire un commentaire qui dit ce que fait la ligne de code. Là il est clair que l'on a un exemple de commentaire inutile à montrer dans les écoles d'informatiques !!!!

Mais les commentaires sont indispensables, MEME pour des fonctions simple.
Si tu fais une fonction qui ecrit un texte dans un fichier texte, il est bien de mettre un commentaire pour signaler son intérêt, qu'elle est son but, ... Bref un truc qui permet de comprendre pourquoi on l'appelle et quand est ce qu'il faut l'appelle.
Cela peut être déjà expliqué dans un document de conception détaillé qui explique le fonctionneemnt de tes composants, tes classes, tes méthodes et leurs algos !!! Mais un document cela se perd, et bien souvent celui-ci n'existe pas.
Alors que si tu perds le code ou s'il n'existe pas, le commentaire on s'en tape, mais si tu as le code, tu as forcément les commentaires.

En c#, ce que propose Guulh est tout à fait adapté, et même très bien.

[Guulh]

A vue de nez, c'est une implémentation de bitfield. On utilise un Int32, par exemple, pour stocker 32 valeurs booléennes. Ca semble être le cas ici, puisque Ox20 = 32 en décimal. A noter que ce code n'est pas spécifique à C#, ça serait quasiment le même en C, C++, java ou même D (objective C aussi, peut être )

[Nikoui]

Justement, C# (et pas DotNet) a un système de commentaires XML sur lequel se base Intellisense pour afficher une aide contextuelle sur chaque objet / fonction / enum... C'est super bien foutu quand même, la MSDN est basée là-dessus Après, sûr que des commentaires style "on boucle de 0 à 99" sont à jeter.

En fait je reprendrai ce que dit Chubyone en modifiant de cette façon :

- Je commente toujours les méthodes
- Le corps des fonctions n'a normalement pas besoin d'être commenté.
- Si une partie du corp d'une méthode nécessite des commentaires (parce qu'elle complexe, ou "tordue") alors un peu de refactoring et on extrait cette partie dans une méthode dédiée (qui elle sera commentée, cf premier point).

Et donc au final, il est très rare que j'ai des commentaires "//" dans mon code.

[ced600]

En fait je reprendrai ce que dit Chubyone en modifiant de cette façon :

- Je commente toujours les méthodes
- Le corps des fonctions n'a normalement pas besoin d'être commenté.
- Si une partie du corp d'une méthode nécessite des commentaires (parce qu'elle complexe, ou "tordue") alors un peu de refactoring et on extrait cette partie dans une méthode dédiée (qui elle sera commentée, cf premier point).

Et donc au final, il est très rare que j'ai des commentaires "//" dans mon code.

Va falloir un exemple, car vous partez dans des généricités alors que tout code est particulier, et que les commentaires sont nécessaires dans le cor même des méthodes dans certains cas. Il ne faut appliquer la philo : pas de commentaire dans le corps de la méthode. Mais la philo : un commentaire si besoin !!!!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Text;
using TDAPIOLELib;
 
static public class TDManager
    {
        static private TDConnectionClass tdc;
        static private string TestName;
        static private string TestPath;
        static private string TestSetName;
        static private Test CurrentTest;
 
        static public void Init(string testname, string testsetname, string testpath)
        {
            TestName = testname;
            TestSetName = testsetname;
            TestPath = testpath;
            tdc = new TDConnectionClass();
            tdc.InitConnectionEx("http://qsdidbsjsdfnsvslv.dqs");
            tdc.Login("fgsdfs", "sdfsdf!");
            tdc.Connect("sfsgfgd", "fsdtgrgertg");
        }
}

Rien de très compliqué mais sans commentaire vous ne comprenez pas ce que je fais rééllement. Vous pouvez essayé de le deviner, mais vous perdez du temps que si je vous l'avez dit dans les commentaires, même pas besoin de réfléchir.

[nitteo]

bon ok
désolé pour les commentaires, je viens du C++ moi

pourrions nous revenir au sujet SVP
merci.

[Nikoui]

Rien de très compliqué mais sans commentaire vous ne comprenez pas ce que je fais rééllement. Vous pouvez essayé de le deviner, mais vous perdez du temps que si je vous l'avez dit dans les commentaires, même pas besoin de réfléchir.

Je n'ai pas dit aucun commentaire, mais des commentaires dans les entêtes de méthodes (via la syntaxe C#). Je commente aussi les variable (toujours via la syntaxe C#). Si tu ajoutes à ça des règles de nomage explicite pour les méthodes et variables (ce qui est le cas dans ton exemple), pas besoin d'en rajouter pour comprendre (sauf cas très particulier, mais comme je le disais dans mon cas c'est très rare que j'ajoute des commentaire dans le corp d'une méthode).

[Chubyone]

- Je commente toujours les méthodes
- Le corps des fonctions n'a normalement pas besoin d'être commenté.
.

C'est ce que je voulais dire dans "ne pas commente le code" - l'intérieur des méthodes : le code est censé est lisible et compréhensible à la première lecture (pourvu qu'on est des normes de codes assez explicites et descriptives.. pas du int x; int z; object o; List<> 1a... )

Bien sur les Commentaires Propriétés et Méthodes sont indispensables. D'aileurs je haïs les bibliothèques qui ne prennent même pas le temps de le faire.

En fait c'est juste une règle à se donner "pas de commentaires à l'intérieur des méthodes" : ca force à écrire du code clean et lisible rapidement.
Bien sur, si j'ai 2 3 traitements à la suite je découpe avec des "// fait ceci //fait cela "
Mais la majorité du temps mes variables sont suffisament explicites que je me me passe de décrire chaque ligne

Guuhl à l'air d'avoir mis la main dessus : le type aurait pu mettre un bref descriptif dans le commentaire méthode, voir meme un lien pour se renseigner.

C'est comme lorsque l'on utilise un DP : on en profite pour préciser lequel, ca aide tout de suite celui qui vient après.

[ced600]

Vous allez considérer que cherche la petite bête, mais sur la question des commentaires je suis intraitable.

Je vous ai mis tout le code de ma classe sans commentaire.
Maitenant je vous met au défie de me dire ce que fait ma deuxième méthode.
Et je n'accepte pas la réponse : "elle télécharge les fichiers attachés" -> trop facile.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
static public class TDManager
    {
        static private TDConnectionClass tdc; //Classe permettant de gérer la connection à TestDirector.
        static private string TestName;
        static private string TestPath;
        static private string TestSetName;
        static private Test CurrentTest;
        static private TestFactory TFac; //Classe gérant l'ensemble des tests sous testdirector.
        static private TDFilter TFilter; //Classe gérant les filtre à appliquer sur une liste.
 
        static public void Init(string testname, string testsetname, string testpath)
        {
            TestName = testname;
            TestSetName = testsetname;
            TestPath = testpath;
            TFac = (TestFactory)tdc.TestFactory;
            TFilter = (TDFilter)TFac.Filter;
 
            tdc = new TDConnectionClass();
            tdc.InitConnectionEx("http://qualitycenter.rd.francetelecom.fr/qcbin/");
            tdc.Login("uspa8495", "Daidou2004!");
            tdc.Connect("MEADOWS", "MEADOWS_S_I_FT");
        }
 
        /// <summary>
        /// Télechage les fichiers associés au test lancé sous TestDirector.
        /// </summary>
        static public void DownloadAttachedFiles()
        {
            TDAPIOLELib.List liste; //Liste regroupant des tests.
            TDAPIOLELib.List Att; //Liste des fichiers attachés.
            AttachmentFactory AttFac; //Classe gérant les fichiers attachés.
            ExtendedStorage ExtStorage; //Classe apportant des méthode supplémentaire à AttachmentFactory.
            string path = "";
 
            TFilter["TS_NAME"] = TestName;
            TFilter["TS_SUBJECT"] = "Subject\\" + TestPath;
            liste = TFac.NewList(TFilter.Text);
            if (liste.Count != 0)
            {
                CurrentTest = (Test)liste[1];
            }
            AttFac = (AttachmentFactory)CurrentTest.Attachments;
 
            Att = AttFac.NewList("");
            for (int i = 1; i <= Att.Count; i++)
            {
                ExtStorage = (ExtendedStorage)((Attachment)Att[i]).AttachmentStorage;
                ExtStorage.ClientPath = "c:\\temp";
                ((Attachment)Att[i]).Load(true, ref path);
            }
        }
}

Edit :
je vous ai apporté les comemtnaire que vous auriez mis selon vos postes.