Tableaux .Net avec limite inférieure > 0

Question

Bien que ce soit peut-être une chose bizarre à faire, je dois créer un tableau dans .Net avec une limite inférieure> 0.Cela semble à première vue possible, en utilisant :

Array.CreateInstance(typeof(Object), new int[] {2}, new int[] {9});

Produit les résultats souhaités (un tableau d'objets avec une limite inférieure définie sur 9).Cependant, l'instance de tableau créée ne peut plus être transmise à d'autres méthodes en attendant Object[] me donnant une erreur disant que :

System.Object[*] ne peut pas être jeté dans un System.Object[].Quelle est cette différence dans les types de tableaux et comment puis-je surmonter cela ?

Modifier:code d'essai =

Object x = Array.CreateInstance(typeof(Object), new int[] {2}, new int[] {9});
Object[] y = (Object[])x;

Ce qui échoue avec :"Impossible de convertir un objet de type 'System.Object[*]' en 'System.Object[]'."

Je voudrais également souligner que cette approche FAIT fonctionne lorsque vous utilisez plusieurs dimensions :

Object x = Array.CreateInstance(typeof(Object), new int[] {2,2}, new int[] {9,9});
Object[,] y = (Object[,])x;

Ce qui fonctionne bien.

Answer 1

Cet article ici l'explique: http://www.panopticoncentral.net/2004/03/17/non-zero-lower-bounded-arrays-the-other-side-of-the-coin/

Answer 2

La raison pour laquelle vous ne pouvez pas passer de l'un à l'autre est que c'est maléfique.

Disons que vous créez un tableau d'objets [5..9] et que vous le transmettez à une fonction F en tant qu'objet [].

Comment la fonction saurait-elle qu'il s'agit d'un 5..9 ?F attend un tableau général mais il en obtient un contraint.On pourrait dire qu'il est possible qu'il le sache, mais cela reste inattendu et les gens ne veulent pas effectuer toutes sortes de vérifications de limites à chaque fois qu'ils souhaitent utiliser un simple tableau.

Un tableau est la structure la plus simple en programmation, le rendre trop compliqué le rend inutilisable.Vous avez probablement besoin d'une autre structure.

Ce que vous devriez faire, c'est une classe qui est une collection contrainte qui imite le comportement souhaité.De cette façon, tous les utilisateurs de cette classe sauront à quoi s’attendre.

class ConstrainedArray<T> : IEnumerable<T> where T : new()
{
    public ConstrainedArray(int min, int max)
    {
        array = new T[max - min];
    }

    public T this [int index]
    {
        get { return array[index - Min]; }
        set { array[index - Min] = value; }
    }

    public int Min {get; private set;}
    public int Max {get; private set;}

    T[] array;

    public IEnumerator<T> GetEnumerator()
    {
        return array.GetEnumarator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return array.GetEnumarator();
    }

}

Answer 3

Je ne sais pas pourquoi cela ne peut pas être transmis en tant qu'Object[], mais ne serait-il pas facile si vous créiez simplement une vraie classe pour envelopper un tableau et y gérer votre « logique étrange » ?

Vous bénéficieriez des avantages de l’utilisation d’un véritable objet de référence si vous pouviez ajouter de « l’intelligence » à votre classe.

Modifier:Comment lancez-vous votre tableau, pourriez-vous publier un peu plus de code ?Merci.

Answer 4

Stockez simplement votre limite inférieure dans un entier de décalage const et soustrayez cette valeur de tout ce que votre source renvoie comme index.

Aussi:il s'agit d'une ancienne fonctionnalité VB6.Je pense qu'il pourrait y avoir un attribut pour aider à le prendre en charge.