Discussion :

[Bobiciel]

Bonjour,

Je débute en C# et je cherche désespérement un équivalent à l'instruction "WITH" du langage pascal object de Delphi. Pour les portions de code ou l'on fait des traitements qui portent principalement sur un objet dont le nom est long, cette instruction permet d'alléger le code et d'en faciliter la lecture.

D'avance merci

Bob

[Guulh]

Hello,

ça existe en VB.Net, mais pas en C#.

Je sais que c'est un sujet de troll entre VBistes (et Delphistes, visblement ) et les C#istes, mais perso j'ai jamais compris à quoi ça servait : j'ai jamais eu dans mon code à appeler plusieurs fois des méthodes / champs d'un même objet dont le nom serait trop long. Le mot clé foreach, entre autres, limite ce 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
for (int i = 0 ; i < biduleAvecunNomCompliquéDeLaMort.Length ; i++)
{
  biduleAvecunNomCompliquéDeLaMort[i].Truc = Oualala(biduleAvecunNomCompliquéDeLaMort[i].Machin);
  biduleAvecunNomCompliquéDeLaMort[i].Chose = Choubidou(bidou);
 ...
}
 
//versus
foreach(Truc t in biduleAvecunNomCompliquéDeLaMort)
{
  t.Truc = Oualala(t.Machin);
  t.Chose = Choubidou(bidou);
 ...
}

[Bobiciel]

Merci Guulh pour cette réponse.
Concernant le foreach, c'est très bien pour énumérer les éléments d'un tableau ou d'une collection.
dan mon cas, je n'ai qu'un seul objet à énumérer ...
Du peux développer le "entre autre" stp ;-)

Je regarde comment on tag du code sur le forum, et je poste un message avec un exemple.

a+

Bob

[Bobiciel]

Exemple de code pour lequel je souhaite utiliser WITH :

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
 
            if ((Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Time - DateTime.Now) <= TimeSpan.Parse("00:00:00"))
            {
                /* Chargement des données depuis l'automate programmable */
                if (Proxy_Machine_List[current_Proxy_Machine].Load_Values_From_PLC())
                {
                    Proxy_Machine_List[current_Proxy_Machine].Attempt_Count = 0;
                    Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Time = Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Time.Add(TimeSpan.Parse(Proxy_Machine_List[current_Proxy_Machine].Schedules.Period));
 
                    Proxy_Machine_List[current_Proxy_Machine].Analyse_Events_History();
 
                    /* Le nom du fichier cible est construit de la façon suivante : Client/Id */
                    string fileName;
                    if (Proxy_Machine_List[current_Proxy_Machine].Customer != "")
                        fileName = Production_Path + Proxy_Machine_List[current_Proxy_Machine].Customer + "\\" + Proxy_Machine_List[current_Proxy_Machine].Id + "_" + DateTime.Now.ToString("yyyyMMdd_HHmm");
                    else
                        fileName = Production_Path + Proxy_Machine_List[current_Proxy_Machine].Id + "_" + DateTime.Now.ToString("yyyyMMdd_HHmm");
 
                    SerializationService.Save(fileName + "." + Production_Extension, Proxy_Machine_List[current_Proxy_Machine]);
                    ODFToolBox.Transform(fileName + "." + Production_Extension, AppDomain.CurrentDomain.BaseDirectory + "Fusion_machine_Production_avec_graphique.ods", fileName + ".ods");
                }
                else
                {
                    Proxy_Machine_List[current_Proxy_Machine].Attempt_Count = Proxy_Machine_List[current_Proxy_Machine].Attempt_Count + 1;
                    if (Proxy_Machine_List[current_Proxy_Machine].Attempt_Count == 1)
                        Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Time = Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Time.Add(TimeSpan.Parse(Proxy_Machine_List[current_Proxy_Machine].Schedules.Second_Attempt));
                    else
                        Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Time = Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Time.Add(TimeSpan.Parse(Proxy_Machine_List[current_Proxy_Machine].Schedules.Next_Attempts));
                }
            }
            this.Busy = false;

Qui deviendrait si je trouve une solution équivalente à WITH :

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
 
with (Proxy_Machine_List[current_Proxy_Machine])
{
            if (Schedules.Next_Time - DateTime.Now) <= TimeSpan.Parse("00:00:00"))
            {
                /* Chargement des données depuis l'automate programmable */
                if (Load_Values_From_PLC())
                {
                    Attempt_Count = 0;
                    Schedules.Next_Time = Schedules.Next_Time.Add(TimeSpan.Parse(Schedules.Period));
 
                    Analyse_Events_History();
 
                    /* Le nom du fichier cible est construit de la façon suivante : Client/Id */
                    string fileName;
                    if (Customer != "")
                        fileName = Production_Path + Customer + "\\" + Id + "_" + DateTime.Now.ToString("yyyyMMdd_HHmm");
                    else
                        fileName = Production_Path + Id + "_" + DateTime.Now.ToString("yyyyMMdd_HHmm");
 
                    SerializationService.Save(fileName + "." + Production_Extension, Proxy_Machine_List[current_Proxy_Machine]);
                    ODFToolBox.Transform(fileName + "." + Production_Extension, AppDomain.CurrentDomain.BaseDirectory + "Fusion_machine_Production_avec_graphique.ods", fileName + ".ods");
                }
                else
                {
                    Attempt_Count = Attempt_Count + 1;
                    if (Attempt_Count == 1)
                        Schedules.Next_Time = Schedules.Next_Time.Add(TimeSpan.Parse(Schedules.Second_Attempt));
                    else
                        Schedules.Next_Time = Schedules.Next_Time.Add(TimeSpan.Parse(Schedules.Next_Attempts));
                }
            }
            this.Busy = false;

Tu vois mieux l'intérêt de cette instruction WITH ;-)

[Arthis]

Pourquoi ne pas faire simplement :

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
 
MonSchedule MonInstance;
 
MonInstance =  Proxy_Machine_List[current_Proxy_Machine].Schedules;
 
 if (MonInstance.Next_Time - DateTime.Now) <= TimeSpan.Parse("00:00:00"))
            {
                /* Chargement des données depuis l'automate programmable */
                if (Load_Values_From_PLC())
                {
                    Attempt_Count = 0;
                    MonInstance .Next_Time = MonInstance.Next_Time.Add(TimeSpan.Parse(Schedules.Period));
 
etc...
}

[Bobiciel]

Merci Arthis, effectivement, ç'est une solution que j'ai envisagée, si le WITH n'existe vraiment pas.
ça ne risque pas de perturber le garbage-collector, ce genre d'affectation ?

[Arthis]

Aucun souci. Quand ta reference à l'objet n'existera plus, ton objet se fera garbage collecté tout seul..

Bon code à toi,

[Bobiciel]

Ok, merci
Bonne journée

[Guulh]

Tu vois mieux l'intérêt de cette instruction WITH ;-)

Non, parce que ça inciterait à faire des fonctions immondes de centaines de lignes avec des if de partout et des for par milliers... Je préfère largement ici créer une sous-méthode qui prend un objet ProxyMachine en paramètre (à supposer que Proxy_Machine_List soit une collection de ProxyMachine), même si elle est à usage unique.

[Bobiciel]

Non, parce que ça inciterait à faire des fonctions immondes de centaines de lignes avec des if de partout et des for par milliers... Je préfère largement ici créer une sous-méthode qui prend un objet ProxyMachine en paramètre (à supposer que Proxy_Machine_List soit une collection de ProxyMachine), même si elle est à usage unique.

Effectivement, je suis d'accord avec toi, il vaut mieux scinder le code en fonctions plus petites et plus spécialisées, mais dans mon cas, il ne s'agit que de 3 if imbriqués c'est raisonnable, non ?

Ceci dit, je retiens également ta solution.

en attendant que le WITH soit implémenté dans une future version de C#

Bonne soirée

Bob

[Gold Bug]

en attendant que le WITH soit implémenté dans une future version de C#

Surtout pas !
Le With masque la nature de l'objet que l'on manipule puisqu'il est non typé.
La seule bonne solution est de passer par une référence intermédiaire comme l'a proposé Arthis. Cela permet au passage de vérifier que cette référence n'est pas nulle... plutôt utile si on ne veut pas se prendre de "Null Reference Exception" dans les cas limites ou non testés