Escrever sua própria camada de acesso a dados / mapeamento de dados é uma idéia "boa"?

Atualmente, estamos em uma situação em que temos a opção de usar um mapeador relacional de objetos pronto para uso ou lançar nosso próprio

Temos um aplicativo herdado (ASP.NET + SQL Server) em que a camada de dados e a camada de negócios infelizmente estão unidas. O sistema não é particularmente complicado em termos de acesso a dados. Ele lê dados de um grande grupo (35-40) de tabelas inter-relacionadas, manipula-os na memória e salva-os novamente em algumas outras tabelas em um formato de resumo. Agora temos a oportunidade de refatoração e estamos analisando as tecnologias candidatas a serem usadas para separar e estruturar adequadamente nosso Acesso a Dados.

Seja qual for a tecnologia que decidirmos, gostaríamos de:

• temos objetos POCO em nosso Modelo de Domínio que são Ignorantes de Persistência
• ter uma camada de abstração para permitir teste de unidade de objetos de modelo de domínio em relação a uma fonte de dados subjacente simulada

Obviamente, há muitas coisas por aí sobre isso em termos de padrões e estruturas etc.

Pessoalmente, estou pressionando pelo uso da EF em conjunto com o Gerador de repositório testável da unidade ADO.NET / Gerador de entidades POCO . Ele atende a todos os nossos requisitos, pode ser facilmente agrupado em um padrão Repo / UnitOfWork e nossa estrutura de banco de dados está razoavelmente madura (já tendo sido submetida a um refator), de modo que não faremos alterações diárias no modelo.

No entanto, outros membros do grupo estão sugerindo arquitetar / rodar nosso próprio DAL completamente do zero. (DataMappers personalizados, DataContexts, repositório, interfaces em todos os lugares, injeção de dependência em excesso para criar objetos concretos, tradução de consulta LINQ para subjacente personalizada, implementações de cache personalizadas, implementações personalizadas de FetchPlan ...) a lista continua e é franca eu como loucura.

Alguns dos argumentos apresentados são: "Bem, pelo menos, estaremos no controle de nosso próprio código" ou "Oh, eu usei L2S / EF em um projeto anterior e não passava de dores de cabeça". (Embora eu já tenha usado os dois na Produção e tenha encontrado alguns problemas poucos e distantes entre si, e muito gerenciáveis)

Por isso, qualquer um de seus arquitetos / desenvolvedores com experiência no assunto tem alguma palavra de sabedoria que possa me ajudar a desviar esse produto do que me parece ser um desastre completo. Não posso deixar de pensar que qualquer benefício obtido ao se desviar dos problemas da EF será perdido com a mesma rapidez ao tentar reinventar a roda.

Ambos os argumentos contra ORMs existentes são inválidos:

"Bem, pelo menos, estaremos no controle de nosso próprio código"

Por que não escrever sua própria língua? Sua própria estrutura? Seu próprio sistema operacional? E para ter certeza de que você está no controle de tudo, também é uma boa ideia criar seu próprio hardware.

"Oh, eu usei o L2S / EF em um projeto anterior e não passava de dores de cabeça"

A EF é madura o suficiente e foi usada com sucesso por muitas pessoas. Isso significa que uma pessoa que afirma que a EF não passa de uma dor de cabeça provavelmente deve começar a aprender a usar a EF adequadamente.

Então, você precisa escrever seu próprio ORM?

Eu não sugeriria isso. Já existem ORMs de nível profissional, o que significa que você deve escrever seus próprios somente se:

• Você tem um contexto preciso em que todos os ORMs existentes não podem caber por algum motivo,
• Você tem certeza de que o custo de criar e usar seu próprio ORM em vez de aprender um existente é muito menor. Isso inclui o custo do suporte futuro, inclusive por outra equipe de desenvolvedores que precisaria ler centenas de páginas da documentação técnica para entender como trabalhar com o ORM.

Obviamente, nada o proíbe de escrever seu próprio ORM apenas por curiosidade, para aprender coisas. Mas você não deve fazer isso em um projeto comercial.

Veja também os pontos 2 a 3 da minha resposta à pergunta Reinventando a roda e NÃO lamentando. Você pode ver que as diferentes razões para reinventar a roda não se aplicam aqui.

Use o Entity Framework para todo o material CRUD comum (80 a 95% do código) e use o código de acesso a dados personalizado para qualquer código restante que precise ser otimizado. Isso deve satisfazer as preocupações daqueles que estão argumentando que você não tem controle suficiente.

É uma boa idéia se, e somente se, você pode (pelo menos razoavelmente) ter certeza de que economizará pelo menos tanto tempo / esforço escrevendo seu próprio código quanto necessário para gerar esse código em primeiro lugar. Dependendo da situação, isso também pode afetar sua agenda e você precisará levar isso em consideração também. Você também deve considerar a manutenção de longo prazo na equação. Se você criar seu próprio ORM, precisará mantê-lo para sempre (ou pelo menos enquanto você o usar).

O ponto principal é que isso pode fazer sentido, sob as condições certas. Essas condições geralmente incluem:

1. O projeto em que você está trabalhando é bastante grande, portanto o custo é amortizado por uma grande quantidade de uso.
2. Seu uso de dados é suficientemente incomum que as bibliotecas existentes (e outras) funcionem muito mal para seus propósitos.

Correndo o risco de afirmar o óbvio, esses dois têm uma relação inversa - se você estiver trabalhando em um projeto realmente gigantesco, mesmo uma pequena economia em cada uso individual poderá ser suficiente para justificar o desenvolvimento. Por outro lado, se suas necessidades são realmente incomuns, e você ganha muito em cada uso, o trabalho pode ser justificado mesmo em um projeto relativamente pequeno.

Pelo menos com base na sua descrição, no entanto, nenhum dos dois se aplica realmente ao seu caso. Talvez um (ou ambos) tenha se aplicado ao uso anterior da EF por parte de seu colega de trabalho, ou talvez seja apenas preconceituoso - acho que você não forneceu informações suficientes para adivinhar quais (embora, para ser justo, devo acrescentar que eu ' Acho que é porque ele não lhe disse o suficiente para adivinhar).

Se eu estivesse encarregado dessa situação, acho que você e seus colegas de trabalho escreverão um tipo de documento de posição - uma lista de pontos fortes e fracos que você vê em cada abordagem, juntamente com evidências reais para apoiar cada afirmação / reivindicação /tanto faz. Toda a equipe passaria a criticar cada artigo. O ponto principal em sua crítica seria avaliar cada ponto em duas escalas:

1. o grau em que o ponto parece preciso, bem fundamentado em fatos etc., e
2. o grau em que o ponto parece se aplicar ao projeto em questão.

Depois, avaliaria os documentos e as críticas para chegar a uma decisão (embora seja totalmente honesto, pode ser difícil dizer quanto os estava usando para tomar a decisão e quanto os estava usando para justificar uma decisão Eu já tinha feito - eu sei que provavelmente não deveria admitir isso, mas a realidade é que eu também sou humano ...)

Editar:

Se eu quisesse ser particularmente desagradável (ou "educacional" - difícil dizer a diferença nesse caso), cada um de vocês tentaria desenvolver uma estimativa do esforço geral de desenvolvimento, usando um ORM / DAL existente e desenvolvendo seu próprio. Embora seja apenas um palpite, meu palpite imediato é que a maioria das pessoas com grandes planos de apresentar seus próprios projetos não se incomodaria em entregar suas estimativas - no momento em que apresentassem uma estimativa do esforço geral que foi remotamente finalizado (e realistas), eles perceberiam que não havia como chegar perto de competir com o código existente. Ao mesmo tempo, é

Edit 2: (mais ou menos na sugestão de @ CmdKey): Embora não tenha sido explicitamente mencionado, presumo que uma estimativa inclua implicitamente uma avaliação de risco. Em particular, uma estimativa de tempo normalmente deve incluir números no estilo PERT:

1. A melhor estimativa possível do mais rápido que poderia ser feito se tudo desse certo.
2. A estimativa "normal" - quanto tempo você espera que demore.
3. A pior estimativa possível de quanto tempo demoraria se tudo desse errado.

Obviamente, as estimativas dos melhores e dos piores casos normalmente não devem incluir coisas como intervenção divina direta, mas devem incluir quase nada além disso.

Geralmente, nunca é uma boa ideia reinventar a roda, e isso geralmente é uma indicação de ignorância técnica ("não sei mais nada e não quero aprender") ou de arrogância ("X é estúpido, posso escreva minha própria ferramenta em duas semanas! "); Existem ferramentas maduras que podem fazer as coisas muito melhor do que o que um desenvolvedor comum pode hackear em poucas semanas.

Dito isso, no entanto, há momentos em que você não pode ajustar de maneira confiável um aplicativo herdado em torno de uma solução existente (por mais flexível que seja) sem muito trabalho; em um caso como esse, não é uma idéia "boa", mas uma ideia melhor do que as alternativas (ou seja, deixá-la como está ou reescrever metade dela para poder usar a camada de terceiros), para que você tenha pouca escolha.

Eu participei de um projeto que rejeitou as ferramentas Java ORM existentes para criar suas próprias, devido a algum recurso "crítico" que não estava presente no Hibernate. Este foi um erro de vários milhões de dólares e o custo está aumentando diariamente. Eles ainda não têm suporte total para relacionamentos de objetos. Portanto, além de todo o tempo gasto na criação e manutenção da estrutura, eles gastam horas escrevendo código que pode ser escrito em minutos usando o Hibernate, ou, em muitos casos, não precisaria ser escrito.

As estruturas existentes são o produto de dezenas de homens-ano de esforço. É absurdamente ingênuo imaginar que uma única equipe possa chegar perto em algumas semanas-homem.

O código que você precisa escrever é o código que você deve manter. Tempo gasto mantendo o código ORM é o tempo gasto não manter o aplicativo. A menos que o ORM ofereça algum tipo de vantagem estratégica, não é algo que gere dinheiro para os negócios, por isso é pura sobrecarga. Sua empresa prefere gastar dinheiro em despesas gerais ou aprimorar um produto lucrativo? Se for para um aplicativo interno, pode ser um problema, mas você ainda está aumentando a quantidade de código que precisará ser gravada, testada e documentada.

Eu diria que lançar seu próprio ORM é uma péssima idéia - a menos que você tenha uma razão muito, muito boa para fazê-lo (entre. Os que você citou não são bons o suficiente) :)

Cometi um erro uma vez ao fazer com que outras pessoas me convencessem a não usar o ORM e posso dizer que escrever todo o DAL nos deixou muito mais lentos e, em vez de implementar recursos importantes para os negócios, estávamos gastando tempo com o DAL (é muito mais trabalho do que parece).

Os novos EFs parecem muito bons, mas se você quiser mais controle - eu gostaria de ver micro ORM / s como: Drapper http://code.google.com/p/dapper-dot-net/ ou PetaPOCO http : //www.toptensoftware.com/petapoco/

Você também pode misturar e combinar - use EF para a maior parte do material e Drapper para alguns ajustes.

Enfim, isso é apenas o meu 2c;)