Ci sono dei buoni motivi per non usare un ORM?

Durante il mio apprendistato, ho utilizzato NHibernate per alcuni progetti più piccoli che ho maggiormente codificato e progettato per conto mio. Ora, prima di iniziare un progetto più grande, è nata la discussione su come progettare l’accesso ai dati e se utilizzare o meno un layer ORM. Dato che sono ancora nel mio apprendistato e mi considero ancora un principiante nella programmazione aziendale, non ho davvero cercato di spingere a mio avviso, il che è che l’utilizzo di un mappatore relazionale di oggetti nel database può facilitare molto lo sviluppo. Gli altri programmatori del team di sviluppo sono molto più esperti di me, quindi penso che farò solo quello che dicono. 🙂

Tuttavia, non capisco completamente due dei principali motivi per non utilizzare NHibernate o un progetto simile:

  1. Si possono semplicemente build i propri oggetti di accesso ai dati con query SQL e copiare quelle query da Microsoft SQL Server Management Studio.
  2. Il debug di un ORM può essere difficile.

Quindi, ovviamente, potrei semplicemente build il mio livello di accesso ai dati con un sacco di SELECT ecc., Ma qui mi manca il vantaggio dei join automatici, delle classi proxy che caricano pigri e di uno sforzo di manutenzione inferiore se una tabella riceve una nuova colonna o una colonna viene rinominato. (Aggiornamento di numerose query SELECT , INSERT e UPDATE rispetto all’aggiornamento della configurazione della mapping e probabilmente al refactoring delle business class e dei DTO).

Inoltre, usando NHibernate puoi incorrere in problemi imprevisti se non conosci molto bene il framework. Questo potrebbe essere, ad esempio, affidarsi a Table.hbm.xml dove si imposta la lunghezza di una stringa per essere automaticamente convalidata. Tuttavia, posso anche immaginare bug simili in un “semplice” livello di accesso ai dati basato su query SqlConnection.

Infine, questi argomenti sopra menzionati sono davvero una buona ragione per non utilizzare un ORM per un’applicazione enterprise basata su database non banale? Ci sono probabilmente altri argomenti che potrei aver perso?

(Probabilmente dovrei aggiungere che penso che sia come la prima “grande” applicazione .NET / C # che richiederà un lavoro di squadra. Buone pratiche, che sono viste come abbastanza normali in Stack Overflow, come test unitari o integrazione continua, non sono -esistente qui fino ad ora.)

Negli ultimi anni c’è stata un’esplosione di crescita con gli ORM e i tuoi colleghi più esperti potrebbero ancora pensare alla mentalità di “ogni chiamata di database dovrebbe avvenire attraverso una stored procedure”.

Perché un ORM renderebbe le cose più difficili da eseguire il debug? Otterrete lo stesso risultato sia che provenga da un proc memorizzato o dall’ORM.

Immagino che l’unico vero danno che riesco a pensare con un ORM sia che il modello di sicurezza è un po ‘meno flessibile.

EDIT: ho appena riletto la tua domanda e sembra che siano copia e incolla le query in sql in linea. Questo rende il modello di sicurezza lo stesso di un ORM, quindi non ci sarebbe assolutamente alcun vantaggio su questo approccio su un ORM. Se utilizzano query non parametrizzate, ciò costituirebbe effettivamente un rischio per la sicurezza.

La risposta breve è sì, ci sono davvero buone ragioni. In effetti, ci sono casi in cui non puoi semplicemente usare un ORM.

Caso in questione, lavoro per una grande istituzione finanziaria aziendale e dobbiamo seguire molte linee guida sulla sicurezza. Per rispettare le regole e i regolamenti che ci vengono sottoposti, l’unico modo per superare gli audit è quello di mantenere l’accesso ai dati all’interno delle stored procedure. Ora alcuni potrebbero dire che è semplicemente stupido, ma onestamente non lo è. L’uso di uno strumento ORM significa che lo strumento / sviluppatore può inserire, selezionare, aggiornare o eliminare qualsiasi cosa voglia. Le stored procedure offrono molta più sicurezza, specialmente negli ambienti quando si gestiscono i dati dei clienti. Penso che questa sia la ragione principale da considerare. Sicurezza.

Il punto debole degli ORM

Gli ORM sono utili per automatizzare il 95% + delle query in cui sono applicabili. Il loro punto di forza particolare è dove hai un’applicazione con una solida architettura del modello di oggetti e un database che funziona bene con quel modello di oggetti. Se stai facendo una nuova build e hai forti capacità di modellazione nel tuo team, probabilmente otterrai buoni risultati con un ORM.

Potresti avere una manciata di domande che sono meglio fatte a mano. In questo caso, non aver paura di scrivere alcune stored procedure per gestirlo. Anche se intendi trasferire la tua app su più piattaforms DBMS, il codice dipendente dal database sarà in minoranza. Tenendo presente che sarà necessario testare la propria applicazione su qualsiasi piattaforma su cui si intende sostenerlo, un po ‘di ulteriore sforzo di porting per alcune stored procedure non farà molta differenza nel TCO. Per una prima approssimazione, il 98% portatile è altrettanto buono del 100% portatile, e molto meglio di soluzioni complicate o poco performanti per aggirare i limiti di un ORM.

Ho visto che il primo approccio funziona bene su un progetto J2EE molto ampio (100 anni di personale).

Dove un ORM potrebbe non essere la soluzione migliore

In altri casi potrebbero esserci approcci che si adattano all’applicazione meglio di un ORM. I Patterns of Enterprise Architecture di Fowler hanno una sezione sui pattern di accesso ai dati che fa un buon lavoro di catalogazione di vari approcci a questo. Alcuni esempi di situazioni in cui un ORM potrebbe non essere applicabile sono:

  • Su un’applicazione con una base di codice legacy sostanziale delle stored procedure, è ansible utilizzare un layer di accesso ai dati orientato alla funzionalità (da non confondere con linguaggi funzionali) per racchiudere gli sproc degli incumbent. Questo riutilizza il layer di accesso ai dati (e quindi testato e debug) esistente e la progettazione del database, che spesso rappresenta un notevole sforzo di sviluppo e test, e salva la necessità di migrare i dati in un nuovo modello di database. Spesso è un buon modo avvolgere i layer Java su basi di codice PL / SQL legacy, o re-targeting di rich client VB, Powerbuilder o Delphi con interfacce web.

  • Una variante è dove si eredita un modello di dati che non è necessariamente adatto alla mapping OR. Se (per esempio) stai scrivendo un’interfaccia che popola o estrae i dati da un’interfaccia straniera, potresti stare meglio lavorando con il database.

  • Applicazioni finanziarie o altri tipi di sistemi in cui l’integrità dei dati tra sistemi è importante, in particolare se si utilizzano transazioni distribuite complesse con commit a due fasi. Potrebbe essere necessario eseguire il microgestione delle transazioni meglio di quanto un ORM sia in grado di supportare.

  • Applicazioni ad alte prestazioni in cui si desidera ottimizzare l’accesso al database. In questo caso, potrebbe essere preferibile lavorare a un livello inferiore.

  • Situazioni in cui stai utilizzando un meccanismo di accesso ai dati incumbent come ADO.Net che è “abbastanza buono” e giocare bene con la piattaforma è un vantaggio maggiore di quello offerto dall’ORM.

  • A volte i dati sono solo dati – potrebbe essere il caso (ad esempio) che la tua applicazione lavori con “transazioni” anziché con “oggetti” e che questa sia una visione sensata del dominio. Un esempio di questo potrebbe essere un pacchetto finanziario in cui hai transazioni con campi di analisi configurabili. Sebbene l’applicazione stessa possa essere costruita su una piattaforma OO, non è legata a un singolo modello di dominio aziendale e potrebbe non essere a conoscenza di molto più di codici GL, account, tipi di documenti e una mezza dozzina di campi di analisi. In questo caso, l’applicazione non è a conoscenza di un modello di dominio aziendale in quanto tale e un modello di object (oltre alla struttura del libro mastro stesso) non è rilevante per l’applicazione.

Prima di tutto – l’uso di un ORM non renderà più facile testare il codice, né fornirà necessariamente vantaggi in uno scenerio di Continuous Integration.

Nella mia esperienza, mentre si utilizza un ORM può aumentare la velocità di sviluppo, i problemi più importanti che è necessario affrontare sono:

  1. Test del tuo codice
  2. Mantenimento del codice

Le soluzioni a questi sono:

  1. Rendi il tuo codice testabile (usando i principi SOLID )
  2. Scrivi test automatici per la maggior parte del codice ansible
  3. Esegui i test automatici il più spesso ansible

Venendo alla tua domanda, le due obiezioni che elencherai sembrano più ignoranza che altro.

Non essendo in grado di scrivere le query SELECT a mano (che, presumo, è il motivo per cui è necessario il copia-incolla) sembra indicare che c’è urgente bisogno di qualche formazione SQL.

Ci sono due ragioni per cui non utilizzerei un ORM:

  1. È severamente vietato dalla politica della compagnia (nel qual caso andrei a lavorare altrove)
  2. Il progetto richiede un’estrema intensità di dati e l’uso di soluzioni specifiche del fornitore (come BulkInsert) ha più senso.

I soliti scarti sugli ORM (in particolare NHibernate) sono:

  1. Velocità

    Non vi è alcun motivo per cui l’utilizzo di un ORM sia più lento rispetto all’accesso ai dati codificato a mano. Infatti, grazie alla memorizzazione nella cache e alle ottimizzazioni integrate, può essere più veloce. Un buon ORM produrrà una serie ripetibile di query per le quali è ansible ottimizzare lo schema. Un buon ORM consentirà inoltre un efficiente recupero dei dati associati utilizzando varie strategie di recupero.

  2. Complessità

    Per quanto riguarda la complessità, l’uso di un ORM significa meno codice, che in genere significa meno complessità. Molte persone che utilizzano l’accesso ai dati scritto a mano (o generato dal codice) si ritrovano a scrivere il proprio framework su librerie di accesso ai dati “di basso livello” (come scrivere metodi di supporto per ADO.Net). Ciò equivale a una maggiore complessità e, peggio ancora, raramente sono ben documentati o ben testati.
    Se stai cercando in particolare su NHibernate, strumenti come Fluent NHibernate e Linq to NHibernate ammorbidiscono anche la curva di apprendimento.

La cosa che mi fa discutere dell’intero dibattito ORM è che le stesse persone che sostengono che usare un ORM sarà troppo difficile / lento / qualunque siano le stesse persone che sono più che felici usando Linq To Sql o Dataset tipizzati. Mentre il Linq To Sql è un grande passo nella giusta direzione, è ancora anni luce dietro a dove si trovano alcuni ORM open source. Tuttavia, i framework sia per Dated Dated che per Linq To Sql sono ancora estremamente complessi, e usarli per andare troppo lontano (Table = Class) + (CRUD di base) è stupidamente difficile.

Il mio consiglio è che se, alla fine della giornata, non riesci a ottenere un ORM, assicurati che il tuo accesso ai dati sia separato dal resto del codice e che tu segua il consiglio di codifica di Gang Of Four per un’interfaccia Inoltre, procurati un quadro per l’iniezione di dipendenza per effettuare il cablaggio.

(Com’è quello per un rant?)

Ci sono una vasta gamma di problemi comuni per cui gli strumenti ORM come Hibernate sono un dio-invio, e alcuni in cui è un ostacolo. Non so abbastanza del tuo progetto per sapere quale sia.

Uno dei punti di forza di Hibernate è che puoi dire cose solo 3 volte: ogni proprietà è menzionata nella class, nel file .hbm.xml e nel database. Con le query SQL, le proprietà sono nella class, nel database, nelle istruzioni di selezione, nelle istruzioni di inserimento, nelle istruzioni di aggiornamento, nelle istruzioni di eliminazione e in tutto il codice di marshalling e unmarshalling che supporta le query SQL! Questo può diventare molto veloce. D’altra parte, sai come funziona. Puoi eseguire il debug. È tutto a posto nel tuo livello di persistenza, non sepolto nelle viscere di uno strumento di terze parti.

Hibernate potrebbe essere un poster-figlio per la legge di Spolsky sulle astrazioni di Leaky. Esci un po ‘fuori dai sentieri battuti e devi conoscere i profondi meccanismi interni dello strumento. Può essere molto fastidioso quando sai che potresti aver risolto l’SQL in pochi minuti, ma invece stai trascorrendo ore a cercare di ingannare il tuo strumento dang per generare SQL ragionevole. Il debugging è a volte un incubo, ma è difficile convincere le persone che non ci sono state.

EDIT: potresti voler controllare in iBatis.NET se non verranno girati su NHibernate e vogliono il controllo sulle loro query SQL.

EDIT 2: Ecco la grande bandiera rossa, però: “Le buone pratiche, che sono viste come abbastanza normali in Stack Overflow, come il test delle unità o l’integrazione continua, sono inesistenti qui fino ad ora.” Quindi, questi sviluppatori “esperti”, cosa hanno esperienza nello sviluppo? La loro sicurezza del lavoro? Sembra che tu possa essere tra le persone che non sono particolarmente interessate al campo, quindi non lasciare che uccidano il tuo interesse. Devi essere l’equilibrio. Combatti.

Ho lavorato su un progetto in cui non utilizzare un ORM era molto efficace. Era un progetto quello

  1. Doveva essere scalealmente orizzontale sin dall’inizio
  2. Doveva essere sviluppato rapidamente
  3. Aveva un modello di dominio relativamente semplice

Il tempo che ci sarebbe voluto per far funzionare NHibernate in una struttura partizionata orizzontalmente sarebbe stato molto più lungo del tempo impiegato per sviluppare un semplice datamapper che fosse a conoscenza del nostro schema di partizionamento …

Quindi, nel 90% dei progetti che ho lavorato su un ORM è stato un aiuto inestimabile. Ma ci sono alcune circostanze molto specifiche in cui posso vedere non usare un ORM come il migliore.

Permettetemi innanzitutto di dire che gli ORM possono semplificare la vostra vita di sviluppo se integrati correttamente, ma ci sono una serie di problemi in cui l’ORM può effettivamente impedirvi di raggiungere i vostri requisiti e obiettivi dichiarati.

Ho scoperto che quando si progettano sistemi con requisiti di prestazioni elevati, sono spesso sfidato a trovare modi per rendere il sistema più performante. Molte volte, finisco con una soluzione che ha un pesante profilo di prestazioni in scrittura (il che significa che stiamo scrivendo dati molto più di quanto stiamo leggendo i dati). In questi casi, voglio approfittare delle funzionalità che la piattaforma di database mi offre per raggiungere i nostri obiettivi di rendimento (è OLTP, non OLAP). Quindi, se sto usando SQL Server e so di avere molti dati da scrivere, perché non dovrei usare un inserto di massa … beh, come forse hai già scoperto, la maggior parte delle ORME (non so se anche uno solo lo fa) non ha la capacità di sfruttare i vantaggi specifici della piattaforma come l’inserimento di massa.

Dovresti sapere che puoi unire le tecniche ORM e non-ORM. Ho appena scoperto che ci sono una manciata di casi limite in cui gli ORM non sono in grado di supportare i tuoi requisiti e devi aggirarli per quei casi.

Per un’applicazione enterprise non banale basata su database, non è davvero giustificato non utilizzare un ORM.

Caratteristiche a parte:

  • Non utilizzando un ORM, si risolve un problema che è già stato risolto ripetutamente da grandi comunità o aziende con risorse significative.
  • Utilizzando un ORM, il nucleo del tuo livello di accesso ai dati beneficia degli sforzi di debug di quella comunità o azienda.

Per mettere un po ‘di prospettiva nell’argomento, considerare i vantaggi dell’utilizzo di ADO.NET rispetto alla scrittura del codice per analizzare autonomamente il stream di dati tabulari.

Ho visto che l’ignoranza su come utilizzare un ORM giustifica il disprezzo di uno sviluppatore per gli ORM Ad esempio: caricamento ansioso (qualcosa che ho notato che non hai menzionato). Immagina di voler recuperare un cliente e tutti i suoi ordini e per tutti gli elementi di dettaglio dell’ordine. Se ti affidi solo al caricamento lento, ti allontanerai dalla tua esperienza ORM con l’opinione: “Gli ORM sono lenti.” Se impari come usare il caricamento bisognoso, lo farai in 2 minuti con 5 linee di codice, ciò che i tuoi colleghi impiegheranno una mezza giornata per implementare: una query al database e vincolare i risultati a una gerarchia di oggetti. Un altro esempio potrebbe essere la sofferenza di scrivere manualmente query SQL per implementare il paging.

La ansible eccezione all’utilizzo di un ORM sarebbe se tale applicazione fosse un framework ORM progettato per applicare astrazioni di business logic specializzate e progettato per essere riutilizzato su più progetti. Anche se fosse così, tuttavia, si otterrebbe un’adozione più rapida migliorando un ORM esistente con quelle astrazioni.

Non lasciare che l’esperienza dei membri del tuo team senior ti trascini nella direzione opposta dell’evoluzione dell’informatica. Ho sviluppato professionalmente per 23 anni, e una delle costanti è il disprezzo del nuovo dalla vecchia scuola. Gli ORM sono per SQL come il linguaggio C doveva essere assemblato, e puoi scommettere che gli equivalenti a C ++ e C # stanno arrivando. Una riga di codice new-school equivale a 20 linee di vecchia scuola.

Quando è necessario aggiornare 50000000 record. Imposta una bandiera o altro.

Prova a farlo usando un ORM senza chiamare una procedura memorizzata o comandi SQL nativi ..

Aggiornamento 1: prova anche a recuperare un record con solo alcuni dei suoi campi. (Quando hai un tavolo molto “largo”). O un risultato scalare. Anche gli ORM fanno schifo.

AGGIORNAMENTO 2 : Sembra che EF 5.0 beta prometta aggiornamenti in batch, ma questa è una notizia molto calda (2012, gennaio)

Penso che forse quando lavori su sistemi più grandi puoi usare uno strumento di generazione del codice come CodeSmith invece di un ORM … Recentemente ho trovato questo: Cooperator Framework che genera stored procedure SQL Server e genera anche le quadro aziendali, i mapper, i gateway, lazyload e tutta quella roba in C # … dai un’occhiata … è stato scritto da una squadra qui in Argentina …

Penso che sia nel mezzo tra la codifica dell’intero livello di accesso ai dati e l’uso di un ORM …

Personalmente, ho (fino a poco tempo fa) opposto a usare un ORM, e sono abituato a scrivere con un livello di accesso ai dati che incapsula tutti i comandi SQL. L’obiezione principale agli ORM era che non mi fidavo dell’implementazione di ORM per scrivere esattamente l’SQL corretto. E, a giudicare dagli ORM che vedevo (principalmente librerie PHP), penso di aver avuto pienamente ragione.

Ora, la maggior parte del mio sviluppo web sta usando Django, e ho trovato l’ORM incluso davvero conveniente, e dal momento che il modello di dati è express prima nei loro termini e solo successivamente in SQL, funziona perfettamente per le mie esigenze. Sono sicuro che non sarebbe troppo difficile superarlo e integrare con SQL scritto a mano; ma per l’accesso CRUD è più che sufficiente.

Non so di NHibernate; ma credo che sia anche “abbastanza buono” per la maggior parte di ciò di cui hai bisogno. Ma se altri programmatori non si fidano di esso; sarà il principale sospetto su tutti i bug relativi ai dati, rendendo la verifica più noiosa.

Potresti provare a introdurlo gradualmente sul posto di lavoro, concentrandoti prima su piccole applicazioni “ovvie”, come un semplice accesso ai dati. Dopo un po ‘, potrebbe essere utilizzato su prototipi e potrebbe non essere sostituito …

Se si tratta di un database OLAP (ad esempio, dati statici di sola lettura utilizzati per reporting / analisi, ecc.), L’implementazione di un framework ORM non è appropriata. Invece, sarebbe preferibile utilizzare la funzionalità di accesso ai dati nativi del database come le stored procedure. Gli ORM sono più adatti per i sistemi transazionali (OLTP).

Le prestazioni di runtime sono l’unico vero svantaggio che riesco a pensare, ma penso che sia più che un giusto compromesso per quando ORM ti risparmia lo sviluppo / testing / ecc. E nella maggior parte dei casi dovresti essere in grado di individuare i colli di bottiglia dei dati e modificare le strutture degli oggetti per essere più efficienti.

Non ho mai usato Hibernate ma una cosa che ho notato con alcune soluzioni ORM “standard” è una mancanza di flessibilità. Sono sicuro che questo dipende da dove vai e cosa devi fare con esso.

Ci sono due aspetti degli ORM che sono preoccupanti. Innanzitutto, sono codice scritto da qualcun altro, a volte chiuso, a volte open source ma di portata enorme. Secondo, copiano i dati.

Il primo problema causa due problemi. Stai facendo affidamento sul codice degli estranei. Lo facciamo tutti, ma la scelta di farlo non dovrebbe essere presa alla leggera. E se non fa quello che ti serve? Quando lo scoprirai? Vivi dentro la scatola che il tuo ORM disegna per te.

Il secondo problema è uno dei commit a due fasi. Il database relazionale viene copiato in un modello a oggetti. Si modifica il modello dell’object e si suppone che aggiorni il database. Questo è un commit a due fasi e non la cosa più facile da eseguire.

Suggerisco questa lettura per un elenco degli aspetti negativi degli ORM.

http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.aspx

Per quanto mi riguarda, ho trovato gli ORM molto utili per la maggior parte delle applicazioni che ho scritto!

/ Asger

L’esperienza che ho avuto con Hibernate è che la sua semantica è sottile, e quando ci sono problemi, è un po ‘difficile capire cosa sta andando male sotto il cofano. Ho sentito da un amico che spesso uno inizia con Criteria, quindi ha bisogno di un po ‘più di flessibilità e ha bisogno di HQL, e in seguito nota che dopo tutto, è necessario SQL raw (ad esempio, Hibernate non ha il sindacato AFAIK).

Inoltre, con ORM, le persone tendono facilmente ad abusare di mappature / modelli esistenti, il che porta a un object con molti attributi che non sono inizializzati. Quindi, dopo la query, all’interno della transazione Hibernate effettua il recupero di dati aggiuntivi, il che porta a un potenziale rallentamento. Inoltre, purtroppo l’object modello di ibernazione è a volte trapelato nel livello di architettura della vista e quindi vediamo LazyInitializationExceptions.

Per usare ORM, si dovrebbe davvero capirlo. Sfortunatamente si ottiene facilmente l’impressione che sia facile mentre non lo è.

Per non essere una risposta di per sé, voglio riformulare una citazione che ho sentito di recente. “Un buon ORM è come uno Yeti, ognuno parla di uno, ma nessuno lo vede”.

Ogni volta che metto le mani su un ORM, di solito mi trovo alle prese con i problemi / limiti di quell’ORM. Alla fine, sì, fa quello che voglio ed è stato scritto da qualche parte in quella pessima documentazione, ma mi ritrovo a perdere un’altra ora che non avrò mai. Chiunque usasse il nibernetico, quindi il fluente nibernetico su postgresql, avrebbe capito cosa ho passato. La sensazione costante di “questo codice non è sotto il mio controllo” fa davvero schifo.

Non indico le dita o dico che sono cattive, ma ho iniziato a pensare a quello che sto dando via solo per automatizzare CRUD in una singola espressione. Oggi penso che dovrei usare meno gli ORM, forse creare o trovare una soluzione che permetta le operazioni di DB al minimo. Ma sono solo io. Credo che alcune cose siano sbagliate in questa arena ORM, ma non sono abbastanza abile da esprimere ciò che non è.

Penso che ci siano molte buone ragioni per non usare un ORM. Prima di tutto, sono uno sviluppatore .NET e mi piace attenermi a ciò che il meraviglioso framework .NET mi ha già fornito. Fa tutto il ansible per farlo. In questo modo, si rimane con un approccio più standard, e quindi c’è una possibilità molto migliore di qualsiasi altro sviluppatore che lavora sullo stesso progetto in fondo alla strada di essere in grado di raccogliere ciò che è lì e correre con esso. Le capacità di accesso ai dati già fornite da Microsoft sono abbastanza ampie, non c’è motivo di scartarle.

Sono stato uno sviluppatore professionista per 10 anni, ho guidato molti progetti di milioni di dollari di grande successo e non ho mai scritto una volta un’applicazione che doveva essere in grado di passare a qualsiasi database. Perché vorresti mai che un cliente lo facesse? Pianifica attentamente, scegli il database giusto per ciò di cui hai bisogno e segui la procedura. Personalmente SQL Server è stato in grado di fare tutto ciò che ho sempre avuto bisogno di fare. È facile e funziona alla grande. C’è anche una versione gratuita che supporta fino a 10 GB di dati. Oh, e funziona fantastico con .NET.

Recentemente ho dovuto iniziare a lavorare su diversi progetti che utilizzano un ORM come datalayer. Penso che sia male, e qualcosa in più ho dovuto imparare a usare senza alcun motivo. In the insanely rare circumstance the customer did need to change databases, I could have easily reworked the entire datalayer in less time than I’ve spent fooling with the ORM providers.

Honestly I think there is one real use for an ORM: If you’re building an application like SAP that really does need the ability to run on multiple databases. Otherwise as a solution provider, I tell my clients this application is designed to run on this database and that is how it is. Once again, after 10 years and a countless number of applications, this has never been a problem.

Otherwise I think ORMs are for developers that don’t understand less is more, and think the more cool 3rd party tools they use in their app, the better their app will be. I’ll leave things like this to the die hard uber geeks while I crank out much more great software in the meantime that any developer can pick up and immediately be productive with.

I think that using an ORM is still a good idea. Especially considering the situation you give. It sounds by your post you are the more experienced when it comes to the db access strategies, and I would bring up using an ORM.

There is no argument for #1 as copying and pasting queries and hardcoding in text gives no flexibility, and for #2 most orm’s will wrap the original exception, will allow tracing the queries generated, etc, so debugging isnt rocket science either.

As for validation, using an ORM will also usually allow much easier time developing validation strategies, on top of any built in validation.

Writing your own framework can be laborious, and often things get missed.

EDIT: I wanted to make one more point. If your company adopts an ORM strategy, that further enhances its value, as you will develop guidelines and practices for using and implementing and everyone will further enhance their knowledge of the framework chosen, mitigating one of the issues you brought up. Also, you will learn what works and what doesnt when situations arise, and in the end it will save lots of time and effort.

Every ORM, even a “good one”, comes saddled with a certain number of assumptions that are related to the underlying mechanics that the software uses to pass data back and forth between your application layer and your data store.

I have found that for moderately sophisticated application, that working around those assumptions usually takes me more time than simply writing a more straightfoward solution such as: query the data, and manually instantiate new entities.

In particular, you are likely to run into hitches as soon as you employ multi-column keys or other moderately-complex relationships that fall just outside the scope of the handy examples that your ORM provided you when you downloaded the code.

I concede that for certain types of applications, particularly those that have a very large number of database tables, or dynamically-generated database tables, that the auto-magic process of an ORM can be useful.

Otherwise, to hell with ORMs. I now consider them to basically be a fad.