L'écriture de votre propre couche d'accès aux données / mappage de données est-elle une «bonne» idée?

Nous sommes actuellement dans une situation où nous avons le choix entre utiliser un mappeur relationnel objet prêt à l'emploi ou rouler le notre

Nous avons une application héritée (ASP.NET + SQL Server) où la couche de données et la couche métier sont malheureusement écrasées ensemble. Le système n'est pas particulièrement compliqué en termes d'accès aux données. Il lit les données d'un grand groupe (35-40) de tables interdépendantes, les manipule en mémoire et les enregistre dans d'autres tables dans un format récapitulatif. Nous avons maintenant la possibilité de refactoriser et étudions les technologies candidates à utiliser pour séparer et structurer correctement notre accès aux données.

Quelle que soit la technologie que nous décidons, nous aimerions:

• avoir des objets POCO dans notre modèle de domaine qui sont ignorants de la persistance
• avoir une couche d'abstraction pour nous permettre de tester nos objets de modèle de domaine contre une source de données sous-jacente simulée

Il y a évidemment beaucoup de choses là-dessus déjà en termes de modèles et de cadres, etc.

Personnellement, je fais pression pour utiliser EF en conjonction avec le générateur de référentiel testable d'unité ADO.NET / le générateur d'entité POCO . Il répond à toutes nos exigences, peut être facilement intégré dans un modèle Repo / UnitOfWork et notre structure de base de données est raisonnablement mature (ayant déjà subi une refactorisation) de sorte que nous n'apporterons pas de modifications quotidiennes au modèle.

Cependant, d'autres membres du groupe suggèrent d'architecturer / rouler complètement notre propre DAL à partir de zéro. (DataMappers personnalisés, DataContexts, référentiel, interfaces partout, dépendance excessive à l'injection de dépendance pour créer des objets concrets, traduction de requête LINQ vers sous-jacente personnalisée, implémentations de mise en cache personnalisées, implémentations FetchPlan personnalisées ...) la liste continue et pour être honnête, il y a des grèves moi comme une folie.

Certains des arguments avancés sont "Eh bien, au moins, nous contrôlerons notre propre code" ou "Oh, j'ai utilisé L2S / EF dans un projet précédent et ce n'était que des maux de tête". (Bien que j'aie déjà utilisé les deux en production auparavant et que je trouve que les problèmes sont rares et très gérables)

Alors, l'un de vos développeurs / architectes très expérimentés a-t-il des paroles de sagesse qui pourraient m'aider à éloigner ce produit de ce qui me semble être un désastre complet. Je ne peux pas m'empêcher de penser que tout avantage obtenu en esquivant les problèmes EF, sera perdu tout aussi rapidement en tentant de réinventer la roue.

Les deux arguments contre les ORM existants ne sont pas valides:

"Eh bien, au moins, nous contrôlerons notre propre code"

Pourquoi ne pas écrire votre propre langue? Votre propre cadre? Votre propre système d'exploitation? Et pour être sûr de tout contrôler, c'est aussi une bonne idée de créer votre propre matériel.

"Oh, j'ai utilisé L2S / EF dans un projet précédent et ce n'était que des maux de tête"

EF est suffisamment mature et a été utilisé avec succès par de nombreuses personnes. Cela signifie qu'une personne qui prétend que EF n'est rien d'autre qu'un mal de tête devrait probablement commencer à apprendre à utiliser correctement EF.

Alors, devez-vous écrire votre propre ORM?

Je ne dirais pas ça. Il existe déjà des ORM de niveau professionnel, ce qui signifie que vous ne devez écrire les vôtres que si:

• Vous avez un contexte précis où tous les ORM existants ne peuvent pas s'adapter pour une raison quelconque,
• Vous êtes sûr que le coût de création et d'utilisation de votre propre ORM au lieu d'en apprendre un existant est beaucoup plus faible. Cela inclut le coût de l'assistance future, y compris par une autre équipe de développeurs qui devrait lire des centaines de pages de votre documentation technique afin de comprendre comment travailler avec votre ORM.

Bien sûr, rien ne vous interdit d'écrire votre propre ORM juste par curiosité, pour apprendre des choses. Mais vous ne devriez pas le faire sur un projet commercial.

Voir également les points 2 à 3 de ma réponse à la question Réinventer la roue et ne pas la regretter. Vous pouvez voir que les différentes raisons de réinventer la roue ne s'appliquent pas ici.

Utilisez Entity Framework pour tous les éléments CRUD ordinaires (80 à 95% du code) et utilisez un code d'accès aux données personnalisé pour tout code restant à optimiser. Cela devrait répondre aux préoccupations de ceux qui soutiennent que vous n'avez pas assez de contrôle.

C'est une bonne idée si et seulement si vous pouvez être (au moins raisonnablement) certain que vous économiserez au moins autant de temps / d'efforts en écrivant votre propre code qu'il faut pour générer ce code en premier lieu. Selon la situation, cela peut également avoir un impact sur votre emploi du temps, et vous devrez également en tenir compte. Vous devez également intégrer la maintenance à long terme dans l'équation. Si vous lancez votre propre ORM, vous devrez le maintenir pour toujours (ou au moins aussi longtemps que vous l'utiliserez).

L'essentiel, c'est que cela peut avoir du sens, dans les bonnes conditions. Ces conditions comprennent généralement:

1. Le projet sur lequel vous travaillez est assez important, donc le coût est amorti sur une grande quantité d'utilisation.
2. Votre utilisation des données est suffisamment inhabituelle pour que les bibliothèques existantes (et autres) fonctionnent assez mal pour vos besoins.

Au risque de dire l'évidence, ces deux sont en quelque sorte inversement liés - si vous travaillez sur un projet vraiment gargantuesque, même une petite économie à chaque utilisation individuelle peut suffire à justifier le développement. À l'inverse, si vos besoins sont vraiment inhabituels, vous gagnez donc beaucoup à chaque utilisation, le travail peut être justifié même sur un projet assez petit.

Cependant, au moins sur la base de votre description, ni l'un ni l'autre ne s'applique vraiment dans votre cas. Peut-être que l'un (ou même les deux) s'est appliqué à l'utilisation précédente de EF par votre collègue, ou peut-être qu'il a juste des préjugés - je ne pense pas que vous nous ayez donné suffisamment d'informations pour même deviner laquelle (bien que, pour être juste, je dois ajouter que je '' Je suppose que c'est parce qu'il ne vous en a pas dit assez pour le deviner).

Si j'étais en charge de cette situation, je pense que je vous demanderais à vous et à vos collègues de rédiger chacun une sorte de document de position - une liste des forces et des faiblesses que vous voyez avec chaque approche, ainsi que des preuves réelles à l'appui de chaque affirmation / revendication. /peu importe. Toute l'équipe aurait alors la possibilité (c.-à-d. Qu'elle serait tenue de) critiquer chaque article. Le point principal de leur critique serait d'évaluer chaque point sur deux échelles:

1. la mesure dans laquelle le point semble exact, bien étayé par des faits, etc., et
2. le degré auquel le point semble s'appliquer au projet en cours.

Ensuite, j'évaluais les articles et les critiques pour arriver à une décision (bien que tout à fait honnête, il pourrait être difficile de dire combien je les utilisais pour prendre la décision, et combien je les utilisais pour justifier une décision J'avais déjà fait - je sais que je ne devrais probablement pas l'admettre, mais la réalité est que je suis aussi humain ...)

Éditer:

Si je voulais être particulièrement méchant (ou "éducatif" - difficile de faire la différence dans ce cas), je demanderais à chacun de vous de faire une estimation de l'effort de développement global à la fois en utilisant un ORM / DAL existant et en développant le tien. Bien que ce ne soit qu'une supposition, ma supposition immédiate est que la plupart des personnes ayant de grands plans pour rouler les leurs ne prendraient pas la peine de remettre leurs estimations - au moment où elles ont présenté une estimation de l'effort global qui a même été terminé à distance. (et réaliste), ils se rendraient compte qu'il n'y avait aucun moyen de se rapprocher de la concurrence avec le code existant. En même temps, c'est '

Edit 2: (en quelque sorte à la suggestion de @ CmdKey): Bien que cela ne soit pas explicitement mentionné, je suppose qu'une estimation inclura implicitement une évaluation du risque. En particulier, une estimation du temps devrait normalement inclure des nombres de style PERT:

1. L'estimation du meilleur cas du plus rapide pourrait être faite si tout allait bien.
2. L'estimation "normale" - combien de temps vous vous attendez à ce qu'il prenne.
3. L'estimation du pire cas du plus long que cela pourrait prendre si tout allait mal.

Bien sûr, les estimations du meilleur et du pire des cas ne devraient normalement pas inclure des choses comme l'intervention divine directe, mais devraient inclure à peu près tout ce qui ne correspond pas à cela.

Habituellement, ce n'est jamais une bonne idée de réinventer la roue, et cela est généralement une indication de l'ignorance technique ("Je ne sais rien d'autre, et je ne veux pas apprendre") ou de l'arrogance ("X est stupide, je peux écrire mon propre outil en deux semaines! "); Il existe des outils matures qui peuvent faire beaucoup mieux que ce qu'un développeur moyen peut pirater ensemble en quelques semaines.

Cela dit cependant, il y a des moments où vous ne pouvez pas adapter de manière fiable une application héritée autour d'une solution existante (quelle que soit sa flexibilité) sans une tonne de travail; dans un cas comme celui-ci, ce n'est pas une "bonne" idée, mais une meilleure idée que les alternatives (c.-à-d. la laisser telle quelle ou en réécrire la moitié pour pouvoir utiliser la couche tierce), donc vous avez peu de choix.

J'étais sur un projet qui rejetait les outils Java ORM existants pour écrire les leurs, en raison d'une fonctionnalité "critique" qui n'était pas présente dans Hibernate. C'était une erreur de plusieurs millions de dollars, et le coût augmente quotidiennement. Ils ne prennent toujours pas totalement en charge les relations d'objet. Ainsi, en plus de tout le temps passé à créer et à maintenir le framework, ils passent des heures à écrire du code qui pourrait être écrit en quelques minutes avec Hibernate, ou dans de nombreux cas, n'aurait pas besoin d'être écrit du tout.

Les cadres existants sont le produit de dizaines d'années-homme d'efforts. Il est absurdement naïf d'imaginer qu'une seule équipe pourrait se rapprocher en quelques semaines-homme.

Le code que vous devez écrire est le code que vous devez conserver. Le temps passé à maintenir le code ORM est le temps passé à ne pas maintenir l'application. À moins que l'ORM ne vous donne une sorte d'avantage stratégique, ce n'est pas quelque chose qui va générer de l'argent pour l'entreprise, c'est donc de purs frais généraux. Votre entreprise préférerait-elle dépenser de l'argent pour ses frais généraux ou pour améliorer un produit rentable? S'il s'agit d'une application interne, cela peut ne pas être un problème, mais vous augmentez toujours la quantité de code qui devra être écrite, testée et documentée.

Je dirais que déployer votre propre ORM est une mauvaise idée - à moins que vous n'ayez une très, très bonne raison de le faire (d'ailleurs, celles que vous avez citées ne sont pas assez bonnes :)

J'ai fait une fois l'erreur de convaincre les autres de ne pas utiliser ORM et je peux vous dire que l'écriture de tous les DAL nous a vraiment ralenti et qu'au lieu d'implémenter des fonctionnalités importantes pour les affaires, nous passions du temps sur DAL (c'est beaucoup plus de travail qu'il n'y paraît).

Les nouveaux sems EF sont plutôt bons, mais si vous voulez plus de contrôle - j'aurais une idée des micro ORM / s comme: Drapper http://code.google.com/p/dapper-dot-net/ ou PetaPOCO http : //www.toptensoftware.com/petapoco/

Vous pouvez également mélanger et assortir - utilisez EF pour l'essentiel et Drapper pour un réglage fin.

Quoi qu'il en soit, c'est juste mon 2c;)