Ma collection séquentielle doit-elle commencer à l'index 0 ou à l'index 1?

Je crée un modèle d'objet pour un appareil qui a plusieurs canaux. Les noms utilisés entre le client et moi sont Channelet ChannelSet. ("Ensemble" n'est pas sémantiquement précis, car il est ordonné et un ensemble approprié ne l'est pas. Mais c'est un problème pour une autre période.)

J'utilise C #. Voici un exemple d'utilisation de ChannelSet:

// load a 5-channel ChannelSet
ChannelSet channels = ChannelSetFactory.FromFile("some_5_channel_set.json");

Console.Write(channels.Count);
// -> 5

foreach (Channel channel in channels) {
    Console.Write(channel.Average);
    Console.Write(",  ");
}
// -> 0.3,  0.3,  0.9,  0.1,  0.2

Tout est dandy. Cependant, les clients ne sont pas des programmeurs et ils seront absolument déroutés par l'indexation zéro - le premier canal est le canal 1 pour eux. Mais, par souci de cohérence avec C #, je veux garder l' ChannelSetindex à partir de zéro .

Cela est sûr de provoquer des déconnexions entre mon équipe de développement et les clients lorsqu'ils interagissent. Mais pire, toute incohérence dans la façon dont cela est géré dans la base de code est un problème potentiel. Par exemple, voici un écran d'interface utilisateur où l'utilisateur final ( qui pense en termes de 1 indexation ) édite le canal 13:

Ce Savebouton va finalement aboutir à du code. Si ChannelSetest 1 indexé:

channels.GetChannel(13).SomeProperty = newValue;  // notice: 13

ou ceci s'il est indexé zéro:

channels.GetChannel(12).SomeProperty = newValue;  // notice: 12

Je ne sais pas vraiment comment gérer cela. Je pense que c'est une bonne pratique de garder une liste ordonnée et indexée d'entiers (les ChannelSet) cohérente avec toutes les autres interfaces de tableau et de liste dans l'univers C # (par indexation zéro ChannelSet). Mais alors, chaque morceau de code entre l'interface utilisateur et le backend aura besoin d'une traduction (soustrayez de 1), et nous savons tous à quel point les erreurs insidieuses et courantes de coup par coup sont déjà.

Alors, une décision comme celle-ci vous a-t-elle déjà mordu? Dois-je zéro index ou un index?

On a l'impression que vous confondez l'identifiant pour le Channelavec sa position dans a ChannelSet. Voici ma visualisation de l'apparence actuelle de votre code / commentaires:

public sealed class ChannelSet
{
    private Channel[] channels;
    /// <summary>Retrieves the specified channel</summary>
    /// <param name="channelId">The id of the channel to return</param>
    Channel GetChannel(int channelId)
    {
        return channels[channelId-1];
    }
}

Il semble que vous ayez décidé que parce que les Channels dans un ChannelSetsont identifiés par des nombres qui ont une limite supérieure et inférieure, ils doivent être des index et donc comme il est basé sur C #, 0. Si la façon naturelle de faire référence à chacun des canaux est un nombre entre 1 et X, faites-leur référence par un nombre entre 1 et X. N'essayez pas de les forcer à être des index.

Si vous voulez vraiment fournir un moyen d'y accéder par un index basé sur 0 (quel avantage cela donne-t-il à votre utilisateur final ou aux développeurs qui consomment le code?), Alors implémentez un indexeur :

public sealed class ChannelSet
{
    private Channel[] channels;
    /// <summary>Retrieves the specified channel</summary>
    /// <param name="channelId">The id of the channel to return</param>
    public Channel GetChannel(int channelId)
    {
        return channels[channelId-1];
    }

    /// <summary>Return the channel at the specified index</summary>
    public Channel this[int index]
    {
        return channels[index];
    }
}

Affichez l'interface utilisateur avec l'index 1, utilisez l'index 0 dans le code.

Cela dit, j'ai travaillé avec des périphériques audio comme celui-ci et utilisé l'index 1 pour les canaux et conçu le code pour ne jamais utiliser "Index" ou indexeurs pour éviter la frustration. Certains programmeurs se plaignaient toujours, alors nous l'avons changé. Ensuite, d'autres programmeurs se sont plaints.

Choisissez-en un et respectez-le. Il y a de plus gros problèmes à résoudre dans le grand schéma consistant à sortir les logiciels.

Utilise les deux.

Ne mélangez pas l'interface utilisateur avec votre code principal. En interne (en tant que bibliothèque), vous devez coder "sans savoir" comment chaque élément du tableau sera appelé par l'utilisateur final. Utilisez les tableaux et collections «naturels» indexés sur 0.

La partie du programme qui joint les données à l'interface utilisateur, la vue, doit veiller à traduire correctement les données entre le modèle mental de l'utilisateur et la «bibliothèque» qui effectue le travail réel.

Pourquoi est-ce mieux?

• Le code peut être plus propre, pas de piratage pour traduire l'indexation. Cela aide également les programmeurs en ne s'attendant pas à ce qu'ils suivent et se souviennent d'utiliser des conventions contre nature.
• Les utilisateurs utiliseront l'indexation qu'ils attendent. Vous ne voulez pas les ennuyer.

Vous pouvez voir la collection sous deux angles différents.

(1) Il s'agit, en premier lieu, d'une collection séquentielle régulière , comme un tableau ou une liste. L'index de 0est donc évidemment la bonne solution, suivant la convention. Vous allouez suffisamment d'entrées et mappez le numéro de canal aux indices, ce qui est trivial (il suffit de soustraire 1).

(2) Votre collection est essentiellement un mappage entre les identifiants de canal et les objets d'informations de canal. Il se trouve que les identifiants de canal sont une plage séquentielle d'entiers; demain ce pourrait être quelque chose comme [1, 2, 3, 3a, 4, 4.1, 6, 8, 13]. Vous utilisez cet ensemble ordonné comme clés de mappage.

Choisissez l'une des approches, documentez-la et respectez-la. Du point de vue de la flexibilité, j'irais avec (2), car la représentation du numéro de canal (au moins le nom affiché) est relativement susceptible de changer à l'avenir.

Tout le monde et son chien utilisent des index à base zéro. L'utilisation d'index à base unique dans votre application vous causera des problèmes de maintenance pour toujours.

Maintenant, ce que vous affichez dans une interface utilisateur, cela dépend entièrement de vous et de votre client. Affichez simplement i + 1 comme numéro de canal, ainsi que le canal #i, si cela rend votre client heureux.

Si vous exposez une classe, vous l'exposez aux programmeurs. Les personnes que vous confondez avec un index de base zéro ne sont pas des programmeurs, il y a donc une déconnexion ici.

Vous semblez vous inquiéter de la conversion entre l'interface utilisateur et le code. Si cela vous inquiète, créez une classe portant la représentation de l'interface utilisateur d'un numéro de canal. Un appel transformant le numéro 12 en représentation d'interface utilisateur "Canal 13", et un appel transformant "Canal 13" en numéro 12. Vous devez le faire de toute façon, au cas où le client changerait d'avis, il n'y a donc que deux lignes de code changer. Et cela fonctionne si le client demande des chiffres romains ou des lettres de A à Z.

Vous mélangez deux concepts: l'indexation et l'identité. Ils ne sont pas la même chose et ne doivent pas être confondus.

Quel est le but de l'indexation? Accès aléatoire rapide. Si les performances ne sont pas un problème, et compte tenu de votre description, ce n'est pas le cas, alors l'utilisation d'une collection qui a un index est inutile et probablement accidentelle.

Si vous (ou votre équipe) êtes confus par l'index par rapport à l'identité, vous pouvez résoudre ce problème en n'ayant pas d'index. Utilisez un dictionnaire ou un énumérable et obtenez le canal par valeur.

channels.First(c=> c.Number == identity).SomeProperty = newValue;
channels[identity].SomeProperty = newValue;

Le premier est plus clair, le second est plus court - ils peuvent ou non être traduits dans le même IL, mais de toute façon, étant donné que vous l'utilisez pour une liste déroulante, cela devrait être assez rapide.

Vous exposez une interface à travers votre ChannelSetclasse avec laquelle vous attendez de vos utilisateurs qu'ils interagissent. Je le rendrais aussi naturel pour eux que possible. Si vous pensez que vos utilisateurs commenceront à compter à partir de 1 au lieu de 0, exposez cette classe et son utilisation en gardant cette attente à l'esprit.

L'indexation basée sur 0 était populaire et défendue par des personnes importantes, car la déclaration indique la taille de l'objet.

Avec les ordinateurs modernes, avec les ordinateurs que vos utilisateurs utiliseront, la taille de l'objet est-elle importante?

Si votre langauge (C #) ne prend pas en charge une manière propre de déclarer le premier et le dernier élément d'un tableau, vous pouvez simplement déclarer un tableau plus grand et utiliser des constantes déclarées (ou une variable dynamique) pour identifier le début et la fin logique de la zone active de la matrice.

Pour les objets d'interface utilisateur, vous pouvez presque certainement vous permettre d'utiliser un objet dictionnaire pour votre mappage (si vous avez 10 millions d'objets, vous avez un problème d'interface utilisateur) et si le meilleur objet dictionnaire se révèle être une liste avec gaspillé d'espace à chaque extrémité, vous n'avez rien perdu d'important.