API, versioni e modelli

3

Ho la mia (JSON) API strutturata come questa (di cui sono abbastanza felice):

Progetto API

/_V1
    /Controllers
        V1EntityController.cs        // Applies to version 1 only
/_V2
    /Controllers      
        V2OtherEntityController.cs   // Applies to versions 2 and below
/Controllers/
    EntityController.cs              // Applies to versions 2 and above
    OtherEntityController.cs         // Applies to versions 3 and above

Progetto principale

/Data/Entity.cs
/Data/OtherEntity.cs

Tuttavia, con il progredire del progetto, sia le classi Entity che OtherEntity sono diventate piene di proprietà legacy e un sacco di metodi ShouldSerializexxx . Inoltre, contengono anche proprietà e sottoclassi che sono solo per la serializzazione.

Sarebbe una soluzione migliore per creare "Modelli" nel progetto API in questo modo:

Progetto API

/_V1
    /Controllers
        V1EntityController.cs
    /Models
        V1EntityModel.cs
/_V2
    /Controllers      
        V2OtherEntityController.cs
    /Models
        V2OtherEntityModel.cs
/Controllers
    EntityController.cs
    OtherEntityController.cs
/Models
    EntityModel.cs
    OtherEntityModel.cs

Quindi convertire da e verso le classi nel progetto principale? Qual è la pratica riconosciuta nel settore per la gestione di questo scenario?

    
posta Jamie 06.01.2014 - 12:49
fonte

2 risposte

2

Il mio voto è sul tentativo di evitare tali scenari. Normalmente, non mi interessa quando aggiungo nuovi membri a una classe, perché la maggior parte dei consumatori non si preoccupa nemmeno delle nuove cose che appaiono. Ma ovviamente rimuovere i membri è un cambiamento irrisolto, ma queste cose accadono continuamente, devi solo comunicarle. Direi che i cambiamenti bruschi sono lo standard del settore, è solo più economico e non finisce con il codice disordinato.

La mia soluzione preferita è in WCF, vedi per esempio qui: link . Fondamentalmente, quando aggiungi una nuova proprietà alla tua classe di dati, i client non si preoccupano affatto, e potrai anche recuperare quei dati in un round-trip, grazie all'infrastruttura IExtensibleDataObject.

Se davvero devi supportare diverse versioni di classi di dati allo stesso tempo, allora proverei a separare le classi, una nuova classe per ogni nuova versione. Vorrei utilizzare interfacce, ereditarietà, modelli di visualizzazione per versioni diverse o persino strumenti come AutoMapper per ridurre la quantità di codice copiato dalla copia.

    
risposta data 07.01.2014 - 13:36
fonte
1

Ho provato un paio di approcci diversi: versione dell'intero progetto nel proprio spazio dei nomi (ad esempio controller v1, modelli, ecc.) o solo versione di ciò che è necessario (ad esempio il controller v3 utilizza l'operazione v2 che utilizza i repository v1, ecc.) . A seconda della complessità del software, ognuno ha i suoi pro e contro. Siamo arrivati a un punto in cui solo la versione di ciò che è necessario alla versione diventerà finalmente ingestibile. Ad esempio, se si utilizzano interfacce generiche, si incontrerà inevitabilmente la situazione in cui il controllo delle versioni di qualcosa che implementa quell'interfaccia ti costringerà alla versione di tutto il resto della catena che non è bueno. Se hai fatto un buon lavoro separando i contratti dei clienti da oggetti di dominio e entità di database, allora dovresti essere un po 'meglio perché in realtà stai solo mappando i contratti dei tuoi clienti al tuo oggetto dominio, e dato che l'oggetto dominio non dovrebbe davvero aver bisogno per essere versionato tutto questo spesso (quasi mai, davvero), dovresti essere abbastanza sicuro. Ci sono altri diversi modelli che possono aiutarti a "spingere" fuori le versioni corrette mentre il percorso è in esecuzione.

La soluzione breve potrebbe essere la versione dell'intera catena, a seconda della frequenza di rilascio. Il tuo progetto può diventare piuttosto grande se rilasci molto e correggere un bug in una versione non lo risolve negli altri, quindi ci sarà molto lavoro extra. Ma, alla fine, è più facile da gestire nel suo insieme dal momento che diventa un [sicuro] per tutti quando l'intera catena è versionata. E dal momento che essere costretti a supportare molte versioni è comunque paralizzante, avere più copie non sembra affatto AS.

    
risposta data 29.01.2014 - 04:29
fonte

Leggi altre domande sui tag