Migration des paramètres de ArrayList à List<T>

Question

J'ai un grand projet qui a été écrit à l'origine en C#1.1 et qui vise maintenant C#2.0. Il y a plusieurs classes qui ont des méthodes qui prennent un paramètre ArrayList. J'aimerais commencer à les déplacer pour qu'elles acceptent les paramètres suivants List<T> comme paramètre, mais cela ne peut pas être fait en une seule fois, je dois donc accepter les deux paramètres.

La raison principale de cette migration est que List<> Les objets seront acceptés en tant que paramètres, mais j'aimerais également profiter de la sécurité des types.

Ont envisagé

1) Créer des surcharges et dupliquer le code. Cela a l'avantage de me permettre de marquer l'ancien style de code comme obsolète, mais il est évident que la duplication du code est mauvaise.

2) Changer le paramètre en IEnumerable : Ceci a l'avantage de fonctionner avec l'ancien et le nouveau code, mais n'est pas sûr du point de vue du type car il acceptera List<T1> où il devrait être List<T2>

3) Réécrire les méthodes pour prendre un List<T> et l'écriture d'un wrapper fin qui prend un paramètre ArrayList et copie les éléments dans un nouveau fichier de type List<T> et appelle ensuite la méthode principale. Cela a également l'avantage de me permettre de marquer l'ancien style de code comme obsolète. Il y aura un léger impact sur les performances et les coûts.

4) Créer trois surcharges. Une méthode privée qui prend IEnumerable et deux méthodes wrapper publiques (une pour ArrayList et une pour List<T> ) qui se contentent d'appeler la méthode privée. Cela a également l'avantage de me permettre de marquer l'ancien style de code comme obsolète. Je ne suis pas sûr qu'il y ait d'autres inconvénients que celui d'avoir trois méthodes.

Je penche pour 4, mais est-ce que je néglige quelque chose ?

Answer 1

Utilisez certainement une variante du n°2, où vous tirez pour IEnumerable<T> plutôt que List<T> . Pour ceux qui ont besoin de plus que IEnumerable<T> votre objectif doit être IList<T> .

Pour les méthodes qui peuvent migrer vers IEnumerable<T> vous pouvez les déplacer vers IEnumerable à court terme, et ainsi éviter de devoir maintenir deux copies de la méthode. Ensuite, une fois que la plupart de vos ArrayLists auront disparu, vous pourrez compléter le passage à IEnumerable<T> avec très peu d'efforts.

Answer 2

Je créerais une suite complète de IEnumerable<t> (ou peut-être IList<t> si vous avez besoin de manipulations plutôt que de capacités d'énumération) des méthodes de paramètres et faites-en vos méthodes par défaut qui font tout le travail. Pour des raisons de compatibilité avec votre contrat ArrayList, vous pourriez alors faire en sorte que vos méthodes ArrayList originales se traduisent elles-mêmes en IEnumerable<t> et appeler le IEnumerable méthodes.

Il s'agit essentiellement de transférer le travail vers l'option la plus sûre en termes de type et de créer une façade pour votre ancien contrat.

Answer 3

J'ajouterais à l'excellente réponse de Joel que vous pouvez éviter la surcharge de copie en utilisant, dans votre phase de transition, la méthode existante comme votre "vraie" méthode et en appelant simplement depuis la méthode IEnumerable<T> à la surcharge IEnumerable un.

Il s'agirait d'un changement rapide et facile, qui n'entraînerait pratiquement aucune incompatibilité binaire.

Vous pouvez marquer le IEnumerable méthode avec [Obsolete("please move to the generic implementation", false)] (en supprimant l'avertissement sur l'autre surcharge) puis passez progressivement à la version "correcte".

Une fois que c'est fait, vous pouvez convertir la méthode réelle en une méthode reposant sur les génériques sûrs et laisser tomber le chaînage.