Discussion :

[mister_rom]

Bonjour à tous,

Je suis en train de convertir une application VB6 en C#, et j'ai un léger soucis dans une déclaration de classe : j'ai une propriété à rédiger (avec des accesseurs donc), en lecture-écriture, qui puisse permettre d'accéder à un tableau de long :

Le tableau est comme suit : private long[] lesFocus = new long[100];
Les appels à la propriété devraient se faire comme ça : MaClasse.LesFocus[index]

Le problème que j'ai est que je n'arrive pas à rédiger correctement cette propriété.
Si je déclare sous cette forme : public long LesFocus[int index] , j'ai des messages d'erreurs.
Si je la déclare sous forme de méthode : public long LesFocus(int index) , les accesseurs ne peuvent pas être utilisés.

Je pourrais écrire 2 méthodes afin de me simplifier la vie (genre SetFocus et GetFocus) mais j'aimerais vraiment savoir si c'est faisable en C#, d'utiliser un tableau avec des accesseurs.

J'espère avoir bien expliqué mon problème, merci d'avance pour votre aide.

[Noxen]

Il te faut déclarer une propriété dont le type est long[].

Code :

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

1
2
3
4
5
6
7
8
9
public class MyData
{
    // With backing field
    private long[] _data = new long[100];
    public long[] Data { get { return _data; } private set { _data = value; } }
 
    // Auto property
    public long[] DataAuto { get; private set; } = new long[100];
}

[MABROUKI]

bonjour

le plus simple en c# c'est les indexers (items en vb.net):

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
 
 public class TempRecord
    {
        // Array of temperature values
        private double[] temps = new double[100] ;
 
        // To enable client code to validate input 
        // when accessing your indexer.
        public int Length
        {
            get { return temps.Length; }
        }
        // Indexer declaration.
        // If index is out of range, the temps array will throw the exception.
        public double this[int index]
        {
            get
            {
                    return temps[index];
            }
 
            set
            {
                temps[index] = value;
            }
        }
    }

bon code...

[mister_rom]

Merci pour les 2 réponses, mais elles ne correspondent pas à mon besoin (le premier propose de gérer un tableau de long, alors que j'aimerais juste exposer un élément du tableau, le second cas avec les indexers me propose un tableau de classe alors que je veux juste une propriété de ma classe sous forme de tableau (en interne) manipulable élément par élement).

[J@ckHerror]

Bonjour,

Il faudra être plus précis et nous expliquer le but de tout ça, parce qu'il n'est pas évidant de comprend ou tu veux aller :

j'aimerais juste exposer un élément du tableau

contre dis

je veux juste une propriété de ma classe sous forme de tableau.

Les conseils donnés plus haut sont justes et correspondent à tes 2 demandes...

Je rajouterais que tu ne retranscriras pas mot à mot un programme de VB6 vers c# ou alors je ne vois pas vraiment l'intérêt... C# est object, il faudra de toute façon que tu te ploge dans l'object un jour ou l'autre donc mon conseil et de reprendre ton programme, liste les fonctionnalités et redéveloppe le mais sans chercehr a faire un copier coller du code... le résultat sera de tout façon assez peu qualitatif à mon avis.

J@ck.

[Pol63]

le second cas avec les indexers me propose un tableau de classe alors que je veux juste une propriété de ma classe sous forme de tableau (en interne) manipulable élément par élement).

non ca fait bien une propriété qui permet d'accéder ou de modifier un seul élément

sinon il faudra passer sur vb.net qui permet de faire des propriétés indexées nommées

[Noxen]

Est-ce-que tu peux mettre le bout de code VB que tu essaies de transposer ?

[mister_rom]

Merci encore pour les réponses.

Je crois que je n'ai pas été assez explicite dans ma description du pb.

Je vais expliquer par analogie :
supposons dans ma classe, j'ai une variable publique LeFocus de type long[] définie comme suit : public long[] LesFocus = new long[100];
il est ensuite facile de faire : MaClasse.LesFocus[10]=0 ou x=MaClasse.LesFocus[10]+5

J'aimerais reproduire ce fonctionnement avec un peu plus de sécurité en passant par des accesseurs sur la propriété LesFocus :
je crée donc une variable de stockage : private long[] lesFocus[] = new long[100];
je crée ma propriété avec mes accesseurs (c'est là où se pose le pb, les accesseurs n'étant pas autorisé pour un appel de propriété par paramètre ...) :
public long LesFocus(int index)
{
get {return lesFocus[index] // exemple de code sans contrôle de l'index}
set {lesFocus[index]=value}
}
à la fin l'utilisation est la même (avec les parenthèses au lieu des crochets of course) : MaClasse.LesFocus(10)=0 ou x=MaClasse.LesFocus(10)+5

En relisant les 2 premières réponses, je me rends compte que le 1er cas (déclarer une propriété de type long[]) correspond le mieux à mon problème, même s'il m'empêche de contrôler la valeur de l'index (utile pour éviter des exceptions en cas de dépassement d'index), en enlevant le private du set.
Par contre, les indexers, j'ai du mal à comprendre comment ça correspond bien à mon besoin, vu qu'il n'est pas possible de nommer la propriété, l'utilisation de this étant obligatoire. Si j'avais 3-4 propriétés fonctionnant comme la 1er, il ne serait à priori pas possible de les déclarer toutes par public type this[int index] ... A moins que j'ai mal capté un truc ...

Je vais donc garder cette 1er réponse. Merci à Noxen.
Je convertis l'application VB6 en C#, en remodelant les grandes fonctionnalités du code (répartit entre composants OCX qui suivent un modèle MVC). Pas de soucis pour la POO, je viens de Java/C++.

B.R

[Pol63]

j'avais bien compris
en c# on ne peut avoir que des propriétés non nommées pour faire ça (en vb.net ca reste possible) et donc une seule par type d'indexer (une long et une string ca passe encore, mais pas 2 int, donc ca limite en effet à une seule propriété indexée)

donc soit tu fais une propriété non nommée, mais qui reste accessible via monInstanceDeClasse[x]
soit tu peux faire une propriété readonly de type long[], qui permettra donc de récupérer le tableau, et d'en lire une valeur ou d'en setter une, mais pas de remplacer le tableau (une propriété avec juste le get, qui retourne la variable privée de type tableau)
cette deuxième solution devrait te convenir, mais ca perd quand même la possibilité de mettre du code dans le set ... genre pour être averti d'une modif

[François DORIN]

En relisant les 2 premières réponses, je me rends compte que le 1er cas (déclarer une propriété de type long[]) correspond le mieux à mon problème, même s'il m'empêche de contrôler la valeur de l'index (utile pour éviter des exceptions en cas de dépassement d'index), en enlevant le private du set.
Par contre, les indexers, j'ai du mal à comprendre comment ça correspond bien à mon besoin, vu qu'il n'est pas possible de nommer la propriété, l'utilisation de this étant obligatoire. Si j'avais 3-4 propriétés fonctionnant comme la 1er, il ne serait à priori pas possible de les déclarer toutes par public type this[int index] ... A moins que j'ai mal capté un truc ...

Simple, il faut autant d'indexers que de propriétés. Tu peux ou bien utiliser des types déjà défini (des tableaux, des List<T>, voir des Dictionary<TKey TType>), ou définir toi-même des indexers. Il peut s'agir d'un indexer générique (style Indexer<T> qui fait les contrôles d'accès comme tu le souhaites), ou faire autant d'indexer que tu as de propriété, en fonction de la nature des contrôles que tu as à effectuer.

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
 
class FocusIndexer
{
   private double[] _data;
 
   public double this[int index]
   {
      get { _data[index];}
      set { _data[index] = value; }
   }
}
 
class BiduleIndexer
{
   private string[] _data;
 
   public string this[int index]
   {
      get { _data[index];}
      set { _data[index] = value; }
   }
}
 
class MaClasse
{
   FocusIndexer LesFocus {get;set;}
   BiduleIndexer LesBidules {get;set;}
}