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.

[Guulh]

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

pourrions nous revenir au sujet SVP
merci.

Lis mon post de 14h31, ça devrait répondre partiellement à ta question.

[Nikoui]

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

Justement avec les commentaires, pas dur de réponde à la question posée (a savoir "que fait la 2em méthode") -> elle télechage les fichiers associés au test lancé sous TestDirector .

Maintenant s'il faut rentrer dans le code (pour débugger par exemple) c'est un peu plus compliqué, mais pour ma part :
- J'aurai donné des noms explicites à mes variables (plutot que list, Att, AttFac, sans parler des majuscules en début de nom )
- J'aurai mis chacune des boucles dans une méthode dédiée (commentée et avec un nom explicite)

En fait, je fais un peu comme le préconise Microsoft dans sa MSF : Quand je rédige une méthode je commence par écrire l'algo en commentaire, puis je remplace chaque ligne de commentaire par le code qui va bien, et si le code en question est trop compliqué, je met ca dans une méthode dédiée (dont le nom reprend souvent l'ancien commentaire).

Edit : Désolé pour le HS.

[nitteo]

Lis mon post de 14h31, ça devrait répondre partiellement à ta question.

ouaih ok
merci ça je le savais.
mais bon ça n'explique pas ce que fait :

union.m_bits[index] &= ~((uint)(((long)1L) << num2));

est ce qu'il fait un décalage avant l'inversion de bit ?
est qu'il fait un ET logique apres ou avant le décalage ?
qu'est ce que c'est le "1L" ?

j'ai beau debugger ce bout de code, je ne vois pas ce qu'il fait comme opération.

[Nikoui]

Alors si je ne dis pas de bêtises (et pour revenir au sujet):
- Le 1L signifie "1 de type long" (un peu redondant avec le '(long)')
- Le décallage est fait en premier
- Le & est fait en dernier

[nitteo]

il manque le ~ (bitwise: inversion de bits)
exemple:
si a = 0x000ffff
~a = 0xffff0000

[ced600]

Justement avec les commentaires, pas dur de réponde à la question posée (a savoir "que fait la 2em méthode") -> elle télechage les fichiers associés au test lancé sous TestDirector .

Maintenant s'il faut rentrer dans le code (pour débugger par exemple) c'est un peu plus compliqué, mais pour ma part :
- J'aurai donné des noms explicites à mes variables (plutot que list, Att, AttFac, sans parler des majuscules en début de nom )
- J'aurai mis chacune des boucles dans une méthode dédiée (commentée et avec un nom explicite)

En fait, je fais un peu comme le préconise Microsoft dans sa MSF : Quand je rédige une méthode je commence par écrire l'algo en commentaire, puis je remplace chaque ligne de commentaire par le code qui va bien, et si le code en question est trop compliqué, je met ca dans une méthode dédiée (dont le nom reprend souvent l'ancien commentaire).

Edit : Désolé pour le HS.

En fait j'ai mal posé ma question, je ne vous demandez pas ce que fait ma méthode, mais ce qu'elle fait et comment elle le fait.

AttFac pour AttachementFactory me semblais parlant (bon pour liste oui j'aurais pu mieux trouver)

A mon avis ce n'est pas simple de comprendre que le début sert juste à récupérer le test courant en récupérant la liste de tous les tests et en appliquant un filtre pour obtenir le test recherché.

J'aurai mis chacune des boucles dans une méthode dédiée

J'en ai qu'une de boucle
En plus je ne sais pas si tu as déjà vu une classe avec plus de 30 méthodes, mais on s'y perd facilement !!!
Trop décomposer n'est pas bon non plus.

[Guulh]

Code :

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

union.m_bits[index] &= ~((uint)(((long)1L) << num2));

ca veut dire qu'il éteint le bit n° num2 dans l'objet.
1L, c'est le long 1.
1 << num2, c'est égal à 2 puissance num2.
ex, avec num2 = 4: (i.e. 1000 binaire)
En résumé : result &= ~00001000, i.e. result &= 11110111
Si tu viens de C++, renseigne toi sur les bitfields.

[ced600]

Justement posté le sujet dans le forum c++ ne serait ce pas plus pertinent ?