équivalent de WITH (Delphi) existe-t-il en C# ?

Version imprimable

24/03/2009, 15h09
Bobiciel

équivalent de WITH (Delphi) existe-t-il en C# ?

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

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:

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

24/03/2009, 15h20
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

Exemple de code pour lequel je souhaite utiliser WITH :

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
 
            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:

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

Pourquoi ne pas faire simplement :

Code:

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

24/03/2009, 15h51
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 ?
24/03/2009, 15h57
Arthis

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

Bon code à toi,
24/03/2009, 16h02
Bobiciel

Ok, merci
Bonne journée
24/03/2009, 16h07
Guulh

Citation:

Envoyé par Bobiciel

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.
24/03/2009, 16h30
Bobiciel

Citation:

Envoyé par Guulh

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# :D

Bonne soirée

Bob
24/03/2009, 18h06
Gold Bug

Citation:

Envoyé par Bobiciel

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 8-)