Propriétés exposer les éléments d'un tableau en C#

Je veux créer une propriété en C# qui définit ou renvoie d'un individu membre d'un groupe. Actuellement, j'ai ceci:

private string[] myProperty;
public string MyProperty[int idx]
{
    get
    {
        if (myProperty == null)
            myProperty = new String[2];

        return myProperty[idx];
    }
    set
    {
        myProperty[idx] = value;
    }
}

Cependant, je reçois l'erreur de compilation suivante:

Mauvais tableau de demande de déclaration: Pour déclarer une matrice le rang spécificateur précède la variable d'identification de l'. Pour déclarer une zone tampon de taille fixe, utilisez le mot-clé fixe avant le type de champ.

codeproject.com/KB/cs/csharptips.aspx

OriginalL'auteur pm_2 | 2010-08-23

arrays c#properties

Comment à ce sujet: écrire une classe qui ne fait qu'une chose et une seule chose: fournir un accès aléatoire aux éléments du sous-jacent indexé de la collection. Donner ce classe un this de l'indexeur.

Pour les propriétés que vous souhaitez fournir un accès aléatoire, il suffit de retourner une instance de cette indexeur de classe.

Implémentation triviale:

public class Indexer<T>
{
    private IList<T> _source;

    public Indexer(IList<T> source)
    {
        _source = source;
    }

    public T this[int index]
    {
        get { return _source[index]; }
        set { _source[index] = value; }
    }
}

public static class IndexHelper
{
    public static Indexer<T> GetIndexer<T>(this IList<T> indexedCollection)
    {
        //could cache this result for a performance improvement,
        //if appropriate
        return new Indexer<T>(indexedCollection);
    }
}

Refactoring dans votre code:

private string[] myProperty;
public Indexer<string> MyProperty
{
    get
    {
        return myProperty.GetIndexer();
    }
}

Cela vous permettra d'avoir autant de indexés propriétés que vous le souhaitez, sans avoir besoin d'exposer ces propriétés avec les IList<T> interface.

OriginalL'auteur Dan Tao

5

Vous devez utiliser this comme le nom de la propriété pour les indexeurs.

Que faire si j'ai plus d'un?
Vous aurez à faire MyProperty retour une sorte de indexables liste. Si vous avez besoin d'un contrôle serré, vous pouvez mettre en œuvre vous-même.

OriginalL'auteur leppie
5

C# ne permet qu'une propriété indexée par classe, de sorte que vous êtes obligé d'utiliser cette.

ce n'est pas vrai. Vous pouvez avoir plus d'un indexeur, tant que la signature est différente, c'est à dire le type de ce qui est utilisé comme la valeur de l'indice est différent.
Les choses ont changé. D'abord une telle limitation n'existe pas. Auriez-vous l'esprit d'affichage des nouvelles de la syntaxe et de nous dire quand il a été ajouté à la langue?
peut-être que nous parlons à la croix: vous pouvez déclarer public int this[string index] le long du côté public int this[int index] et ils peuvent faire deux choses complètement différentes. Je dirais que c'est plus d'une propriété indexée.
L'a obtenu. À partir du concepteur de classes de point de vue vous avez encore une propriété qu'il possède un nom. Imaginez StringList classe, qui dans d'autres langues pourraient avoir des propriétés Cordes[int], les Objets[chaîne], Nom[int], Valeurs[string name] etc. En C# vous ne pouvez pas les mettre en œuvre et même si vous le pouvez, il n'est pas évident et presque inutilisable.

OriginalL'auteur joekoyote

Vous pouvez l'utiliser de cette façon:

    private string[] myProp;
    public string[] MyProp
    {
        get
        {
            if (myProp == null)
            {
                myProp = new String[2];
            }
            return myProp;
        }

        set
        {
            myProp = value;
        }
    }

Et il est possible d'accéder à l'myProp[1] comme MyProp[1] par Exemple

OriginalL'auteur Tokk

2

D'exposer votre tableau par le biais d'une propriété en lecture seule peut répondre à vos besoins. Puisque vous ne voulez pas permettre à d'autres de code afin d'attribuer le tableau en tant que tel, il n'est pas nécessaire pour un public setter:
```
private string[] myProperty;
public string[] MyProperty
{
    get
    {
        if (myProperty == null)
        {
            myProperty = new String[2];
        }

        return myProperty;
    }  
}
```
Ensuite, vous pouvez écrire du code en tant que tel:
```
theObject.MyProperty[1] = "some string";
```
...mais vous ne pouvez pas remplacer le tableau lui-même:
```
theObject.MyProperty = new string[2]; //will not compile
```
OriginalL'auteur Fredrik Mörk
1

Une option est de les réécrire comme suit:
```
private string[] myProperty = new string[2]; 
public string[] MyProperty
{ 
    get 
    { 
        return myProperty;
    } 
    set 
    { 
        myProperty = value; 
    } 
} 
```
Il va compiler, mais il possède son propre ensemble de problèmes (fxCop va hurler, mais il peut vous conduire à d'autres options).

C'est plus fort que l'interface d'origine, qui ne permettent la modification des éléments. Cela permet le remplacement de la sous-matrice de jeu par le biais d'.

OriginalL'auteur Russ

Vous pourriez faire quelque chose comme ceci:

class Indexers
{
    private string[] _strings = new [] {"A","B"};
    private int[] _ints = new[] { 1, 2 };

    public string[] Strings
    {
        get{ return _strings;}
    }

    public int[] Ints
    {
        get{ return _ints;}
    }
}

class Program
{
    static void Main(string[] args)
    {
        Indexers indexers = new Indexers();

        int a1 = indexers.Ints[0];
        string a2 = indexers.Strings[0];
    }
}

OriginalL'auteur fletcher

1

C# fournit pas de mécanisme intégré pour créer indexé propriétés. Vous pouvez utiliser un niveau de classe de l'indexeur (à l'aide de this[int index] notation), mais rien de ce genre sur un niveau de la propriété.

Une option consiste à créer une classe d'assistance avec un indexeur et l'utilisation de cette classe, comme le type de propriété. Voir un exemple sur MSDN.

OriginalL'auteur VladV

Tout d'abord, dans le champ de la déclaration évite l'excès de vérifier:

private string[] myProperty = new string[2];

Vous pouvez mettre en œuvre plusieurs indexeurs via la surcharge par type d'entrée:

public string this[int index]
{
    get
    {
        return myProperty[index];
    }
    set
    {
        myProperty[index] = value;
    }
}

public object this[object a, object b] //different input type(s) (and different return type)
{
    get
    {
        //do other stuff
    }
}

OriginalL'auteur abatishchev

Vous devez utiliser un indexeur. Il fonctionne un peu différemment. Voir l'exemple:

public class Node
{
    public Node this[int offset]
    {
        get { return localList[offset]; }
    }
}

Remarque: Vous n'êtes autorisé seulement un indexeur par classe. La raison en est qu'il est trop confus pour le compilateur, quant à la signification, de sorte que vous ne sont autorisés.

Vous pouvez également le faire:

private static int[] _widget = new int[Counter];
public static int [] Widget
{
    get { return _widget; }
    set { _widget = value; }
}

...

for (int i = 0; i <  MyClass.Counter; i++)
{
    MyClass.Widget[i] = i;
}

...
double _newWidget5 = MyClass.Widget[5];
//and so on...

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.