Usi strumenti di generazione del codice?

https://stackoverflow.com/questions/143855

02-07-2019
|

Domanda

Usi strumenti di generazione del codice (oltre a quelli usati per generare proxy e dai designer integrati a Visual Studio)?

Quali parti dell'applicazione generano?

Di solito fai rotolare il tuo generatore? In tal caso, quale tipo di generatore scrivi (modelli asp, coddom ecc.). In caso contrario, quali strumenti di terze parti usi?

Attualmente sto lavorando a diversi progetti che utilizzano tutti un generatore di codice personalizzato che gestisce tutto, dalla generazione della struttura del database, alle entità aziendali, DAL e BLL. Sono curioso che le esperienze di altre persone siano con questo tipo di strumenti.

Soluzione

Sono nel campo filosofico che considera i generatori di codice come "sbagliati", perché indicano qualcosa che dovrebbe essere inserito nel linguaggio.

Ma è stata una grande parte dell'etica del programmatore pragmatico scrivere codice che scrive codice, e in pratica la generazione di codice funziona bene se il codice generato è nascosto per impostazione predefinita. Non importa quanto filosoficamente puro tu voglia essere, il linguaggio non si evolverà mai così velocemente come i problemi che vuoi risolvere.

Mi viene in mente il codice che viene generato quando si crea un Windows Form in Visual Studio. Se vuoi, puoi guardare il codice generato, ma è meglio non farlo. Passare a un linguaggio dichiarativo con WPF è stato superiore, tuttavia, perché è più pulito e più affidabile manipolare il codice dichiarativo a livello di codice rispetto al codice imperativo.

Avrebbero dovuto fare la stessa cosa con le classi LINQ-To-SQL. Hanno bisogno di un linguaggio dichiarativo per le classi che hanno solo proprietà e nessun comportamento personalizzato. Probabilmente renderebbe più semplice rendere dinamiche quelle classi di entità - cambiando automaticamente quando cambia lo schema del database sottostante.

Abbiamo provato a utilizzare CodeSmith per generare classi .NetTiers per tutte le tabelle nel nostro database, ma abbiamo riscontrato due problemi:

.NetTiers era gonfio e il codice generato era enorme. Penso che gli strumenti per la generazione di codice rendano troppo facile la creazione di creature.
Poiché lo schema era stato sviluppato e rivisto attivamente, anche noi dovevamo rigenerare molto, e ciò ha finito per rendere molto difficile mantenere tutto nel controllo del codice sorgente perché tutti i file venivano rigenerati e sostituiti. Alla fine non ero sicuro che il codice generato dovesse essere nel controllo del codice sorgente.

Il posto migliore per la generazione del codice dovrebbe essere nel compilatore o nella fase di compilazione, non nella fase di progettazione. Quando si utilizza un tipo o metodo anonimo in C #, il compilatore esegue al volo la generazione di codice. Se si genera codice durante la fase di progettazione, si ottiene una parte di elementi che devono essere rigenerati ogni volta che cambiano i parametri sottostanti.

Altri suggerimenti

Sì, ma ci riferiamo a loro come stagisti.

Non che stiamo lavorando nel dominio .net / web, ma gli strumenti di generazione del codice fatti in casa da vari linguaggi progettati in casa sono una parte cruciale della nostra catena di strumenti di sviluppo. Abbiamo due strumenti di questo tipo (con grammatiche e parser e definizioni formali) e una serie di strumenti secondari basati su macro come m4 e perl. Tutti generano C semplice alla fine, che è compilato nativamente.

Le lingue specifiche del dominio sono uno degli strumenti chiave per la produttività dei programmatori per qualsiasi attività software su larga scala nella mia esperienza. Se stai costruendo cose come compilatori, simulatori o altri software molto complicati con molti schemi ricorrenti che non hanno alcun supporto nei linguaggi di base (che in genere significa C portatile e talvolta C ++), gli strumenti per la generazione di codice sono la strada da percorrere. Vedo i linguaggi specifici del dominio come il prossimo passo nella generalizzazione: prima dividi i calcoli comuni in funzioni (o subroutine per essere storici), poi dividi le funzioni comuni in modelli o generici se tale struttura è disponibile, e poi interrompi ancora più comunanza e ripetizione del codice in un linguaggio personalizzato completo.

Si tratta di ridurre il volume di codice effettivamente scritto e di rimuovere qualsiasi forma di noiosa ripetizione e codice senza valore aggiunto dal processo di programmazione. Non appena i pattern si ripetono, applica una lingua specifica del dominio!

Ho iniziato a girare i miei generatori (accesso ai dati, sprocs, ecc.) quando stavo facendo un classico lavoro di asp (circa 2001). Mi sono trasferito lentamente a CodeSmith, poiché era molto più facile da gestire. Stavo ancora generando principalmente tutte le cose del tipo di livello di accesso ai dati (inclusi gli sprocs) per il mio codice .NET.

Un paio di anni fa ho fatto il salto dalla generazione del codice macro (ovvero CodeSmith) alla generazione del codice micro.

La differenza è che con CodeSmith stavo generando enormi quantità di codice per la mia app, tutte generiche e tutte in una volta. Ciò è diventato problematico per casi limite e rigenerazione quando si modifica l'origine per il modello (ovvero la struttura della tabella). Mi sono anche imbattuto in casi in cui c'era un alto inventario di codice di trasporto che non stavo usando, ma è stato generato dal mio modello. Tutti questi metodi hanno funzionato? Forse sì forse no. Entrare e ripulire il codice generato sarebbe stato un'enorme quantità di lavoro (vale a dire dopo più di un anno sulla stessa base di codice).

Micro Code Generation, al contrario, mi permette di generare esattamente le classi di cui ho bisogno, esattamente nello scenario giusto che desidero. Lo strumento principale che uso per fare questo è ReSharper. Il modo in cui lo faccio è scrivere i miei test unitari prima di scrivere il mio codice di produzione. In quello scenario, ReSharper utilizza il mio Unit Test come modello per generare automaticamente lo scheletro per il codice di produzione. Quindi si tratta solo di riempire gli spazi vuoti.

Per l'accesso ai dati, non sto più generando nulla. Ho scoperto che una buona O / R M sostituisce tutto ciò che ho usato per inserire il mio livello di accesso ai dati (cioè NHibernate). Detto questo, non scriverò mai né genererò un altro livello di accesso ai dati in vita mia (mi rifiuto di farlo).

Inoltre, tra l'altro, ho i vantaggi di disporre di una suite di test di unità di grandi dimensioni

Poiché Wasabi, il linguaggio interno di Fog Creek Software, incorpora generatori di codice in fase di compilazione, li usiamo per creare automaticamente la carne delle nostre classi di entità che si associano alle tabelle del database. Quindi, invece di scrivere una classe con una dozzina di proprietà e metodi diversi, possiamo semplicemente scrivere:

<ActiveRecord("Kiwi")> _
Class CKiwi
End Class

e CKiwi avranno Load (ix As Int32), Commit () e campi / proprietà per ogni colonna definita nel suo schema sottostante per la tabella Kiwi. Ci impedisce di avere enormi librerie O / R M, ma ci consente comunque di aggiungere rapidamente una tabella ai nostri prodotti.

La generazione di codice nello spirito dei compilatori può essere eccezionale. Generazione di codice nello spirito di "assistenti" " si è rivelato uniformemente una cattiva idea.

Usavamo CodeSmith per generare i nostri hbms NHibernate, le nostre entità e poche altre cose. Dopo un po 'ci siamo stufati di questo flusso, quindi l'abbiamo abbandonato.

Il generatore T4 è gratuito e vale la pena esaminarlo per generazione.

Usiamo ancora Castle CodeGenerator per la generazione di collegamenti MonoRail.

Utilizziamo generatori di codice per le eccezioni
Generazione di DAO per operazioni CRUD
usa JAXB per generare codice
Utilizzare XDoclet per generare interfacce locali / home EJB
Utilizza i modelli Velocity per generare documentazione per i modelli di business
Utilizza Apache Axis per generare gli stub WSDL

Ho incontrato ActiveWriter un paio di mesi fa e mi ha aiutato moltissimo, ciò che mi piace è la flessibilità di questo approccio, genera classi parziali che gestiscono i problemi di accesso ai dati e mi consente di codificare la parte aziendale delle classi. Mi sento molto soddisfatto perché mi fa risparmiare molto lavoro, è abbastanza bello cambiare lo schema, rigenerare e andare avanti.

Creo i miei strumenti per alcune attività. È divertente da fare e consente anche di risparmiare tempo a lungo termine. Per compiti molto noiosi, salva anche la tua sanità mentale.

I generatori di codice preparati in casa funzionano alla grande per la creazione di casi non complicati da fogli di calcolo per l'utente finale che contengono esempi di come dovrebbe funzionare .

Vedi Strumenti per costruire casi di test per un esempio.

Usiamo LLBLGen per produrre il nostro livello di accesso ai dati. Puntate il generatore sul database che state usando, selezionate quali tabelle volete usare e sfornano le classi necessarie. È tutto molto semplice e veloce.

Abbiamo un generatore di codice integrato che si occupa dell'accesso al database. Uno scrive le procedure memorizzate e ottiene i metodi corrispondenti astratti in una classe gateway.

Generiamo anche servizi web al fine di interfacciarci correttamente con Flash, ovvero gestire l'eccezione in modo sano.

Finalmente abbiamo un generatore di eccezioni che toglie la fatica delle migliori pratiche di eccezione (tonnellate di costruttori, ecc ...)

In un precedente datore di lavoro, avevamo un'applicazione VB.NET cresciuta in casa che trasformava un file XML Schema Definition (XSD) in una libreria C ++ statica. Ciò ha reso molto più semplice lavorare con i tipi di dati C ++ (bool, std :: string, ecc.) E tutto il codice XML interessante è stato nascosto all'interno di queste classi generate.

Abbiamo appena iniziato a utilizzare Grails qui in ufficio. In precedenza, disponevamo di una serie di script di generazione CRS JSF / Hibernate interni.

... Grails vince. La generazione del codice da Grails è molto piacevole e può farti avviare un'app CRUD in circa 15 minuti, senza effettivamente inserire il codice nei file di codice!

Naturalmente, PU CAN generare il codice effettivo nei file di codice, quando si desidera modificarlo. Il più delle volte, per CRUD regolari, puoi cavartela semplicemente cambiando le visualizzazioni.

Ne ho usato uno per generare oggetti dati serializzabili che potrebbero essere riformati su piattaforme diverse (windows, linux, solaris, mac, bsd, ecc.). Era una soluzione interna.

Ho scritto uno strumento adorabile in cui gli esperti nel formato dei dati per cui avevo scritto un parser, potevano inviare i propri campioni tramite un modulo web, guardare l'output e dirmi se era corretto.

Da questo, verrebbe generato un test jUnit. Bella.

Tranne il fatto che nessuna persona si è preoccupata di usarlo e non ho raccolto casi di test.

Come alcuni altri qui, abbiamo anche creato il nostro generatore di codice (Inon Datamanager / Viewmanager) per l'accesso ai dati, la gestione dei moduli HTML e alcune operazioni di logica aziendale. Una chiave per avere bene questo lavoro è progettarlo in modo da non dover mai toccare o guardare il codice generato.

In questo modo, diventa quasi parte del linguaggio - il linguaggio (nel nostro caso Java) viene esteso per includere una specifica del modello di dominio e un modello di visualizzazione, e quindi basta inserire la logica di business personalizzata con codice Java reale.

Questo ci offre gli strumenti giusti per comunicare con analisti e utenti aziendali, pur avendo il potere di Java di impostare i dettagli del comportamento sottostante.

Se sei interessato a LLBLGEN, che è eccellente, potresti anche valutare subsonico. Forse anche vedere cosa ha da dire Rob Conery su eventuali sovrapposizioni o interazioni tra subsonico e t4.

Ho scritto e utilizzato uno strumento di generazione del codice basato su Xslt. http://perfectstorm.codeplex.com/

Utilizza un modello xml a radice singola per generare dal, procs, tables.

Ho creato un framework di generazione di codice personalizzato che genera classi proxy per servizi Web in diversi linguaggi come Java Script, Action Script, Java, C # e Objective C, non utilizzo modelli o strumenti ma solo codice C # che genera codice con alcune classi di supporto, la generazione del codice può davvero far risparmiare molto tempo, ma penso che il codice generato dovrebbe essere il più semplice possibile e non dovrebbe essere abusato.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow