equivalent delphi en c#

Version imprimable

bonjour,

je débute en c# et je cherche des équivalents à ces 2 fonctions Delphi, si ca existe. merci pour l'aide

pour l'utilisation du "in" et dans la déclaration du tableau les ".."
Code:

1 2 3 4 5 6 7 for i := 1 to 15 do begin if i in [1..7] then ... if i in [2,4,6] then if i in [2,4,6,8,10..12] then end;
et dans le même ordre d'idée, le case/switch
Code:

1 2 3 4 5 6 7 case i of 1..5 : 6 : 9..16 : else end;
merci

18/07/2007, 16h07
LefortLudovic
A ma conaissance il n'y a pas l'équivalent du 'in' en c#

par contre le switch case existe
Code:

1 2 3 4 5 6 7 8 9 10 11 12 switch (i) { case 1: xxxxxxx; break; case 2: xxxxxxxx; break; default: xxxxxxxx; }
Ludovic,
18/07/2007, 16h20
b.grellee

je cherche a la fois un équivalent pour le "in" et le ".." pour l'énumération

Code:

1
2
3
4
5
6
7
8
9
10
11
for (int i = 1 ; i < 15 ; i++)
             if (i >=1 && i <=7 && i % 2 != 0)
               {//pas de then en C#
               }
             if (i >=2 && i <=6 && i % 2 = 0)
               {
               }
             if (i >=2 && i <=12 && i % 2 = 0)
               {
               }
         }

par contre pour le switch pour gérer les intervalle, je sais pas mais sinon un intervalle, c'est mathématiquement : i plus grand que XX et à la fois i plus petit que YY. Je vais regarder pour les intervalles en C# mais ca me dit rien du
tout.
++
Antoine

Avec une classe comme cela : tu peux te gérer les intervalles :

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
public struct Intervalle<T> where T : IComparable<T> 
{ 
  T m_left; 
 
  public T Left 
  { 
  get { return m_left; } 
  set { m_left = value; } 
  } 
 
  T m_right; 
 
  public T Right 
  { 
  get { return m_right; } 
  set { m_right = value; } 
  }  
 
  public bool Contains(T value) 
  { 
  if (m_left.CompareTo(value) <= 0 && m_right.CompareTo(value) >= 0) 
  { 
  return true; 
  } 
 
  return false; 
  } 
}

et du coup ton switch donnera cela (ce sera pas un switch du coup) :

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
Intervalle<int> interval1; 
Intervalle<int> interval2; 
interval1 = new Intervalle<int>(); 
interval2 = new Intervalle<int>(); 
 
interval1.Left = 1; 
interval1.Right = 5; 
 
interval2.Left = 9; 
interval2.Right = 16;
 
int i = 5; 
 
if (interval1.Contains(i)) 
{ 
  // Ton interval1 contient bien i :) 
}
if (interval2.Contains(i)) 
{ 
  // Ton interval2 contient bien i :) 
}
if (i == 9) 
{ 
  // i = 9
}

18/07/2007, 17h11
b.grellee

merci NeraOne, je vais tacher d'utiliser ta classe
et voir si tu trouves autre chose
18/07/2007, 17h56
NeraOne
Au niveau intervalle, à ma connaissance, tu ne peux pas gérer ça comme en Delphi, au demeurant très très pratique mais bon... Si quelqu'un pouvais me confirmer cela car je ne suis pas sur de moi...
Sinon le mieux pour t'éviter la classe car ça peut devenir assez chiant à gérer, c'est de remplacer ton switch par une suite de if, else if comme cela :
Code:

1 2 3 4 if (i < 3 && i > 6) {} else if (i < 7 && i > 15) {} else if (i < 16 && i > 20) {} else {/*Ce else est l'équivalent du default dans un switch*/}
Ca paraît peut être un peu relou mais moi je fais comme cela en plus tu peux intégrer pleins de conditions avec les et (&&) et les ou (||). En fait le switch/case ne te permet de gérer que des valeurs ponctuelles en C#, pas d'intervalle.
@++
Antoine

Bonjour,

Avec l'arrivée du .NET 3.5, il n'y a pas eu d'améliorations sur ce point ?

Exemple Delphi :
Code:

1 2 3 4 5 6 case i of 1..3 : mon_code_1; 4, 6 : mon_code_2; 5 : mon_code_3; else mon_code; end;
qui équivaut en C# à :
Code:

1 2 3 4 5 6 7 8 9 10 switch (i) { case 1: case 2: case 3: mon_code_1; break; case 4: case 6: mon_code_2; break; case 5: mon_code_3; break; default : mon_code; break; }
ou encore
Code:

1 2 3 4 5 6 7 8 9 10 11 12 if ((i>=1) && (i<=3)) { mon_code_1; } else if ((i==4) || (i==6)) { mon_code_2; } else if (i==5) { mon_code_3; } else { mon_code; }
Là, il n'y a que 6 valeurs possibles, mais j'ai un truc avec 256 valeurs là ... ça risque d'être beaucoup moins lisible (et pratique) par rapport à la syntaxe Delphi !