2011-08-30 10 views
9

Mi piacerebbe rilevare la rottura delle modifiche nel codice .NET (in particolare C#) ogni volta che TFS crea una soluzione. Se ci sono cambiamenti di rottura (come delineato in "A definite guide to API-breaking changes in .NET") tra il codice in fase di check in e la versione nella build di successo più recente, mi piacerebbe saperlo. Non è necessario che una modifica di rottura causi il fallimento della build. A corto di scrivere un'app che utilizza la riflessione per confrontare due versioni dello stesso assembly, come può essere fatto?Rilevare i cambiamenti di interruzione nel codice .NET usando TFS?

+1

Attraverso la revisione del codice? – Mrchief

+0

Domanda collegata: http://stackoverflow.com/questions/2377855/tool-for-back-compatibility-for-the-c-net-api – aponomarenko

risposta

3

Sì, vorrei (e faccio) usare NDepend per questo. Lavoro su un prodotto che fornisce un'API estendibile per gli sviluppatori. In quanto tale, dobbiamo fare in modo che tra una release e l'altra non rimuoviamo la funzionalità da cui questi sviluppatori possono dipendere. Il rovescio della medaglia, è che abbiamo bisogno della flessibilità per far crescere il prodotto senza enormi vincoli attorno al ritorno.

Alcune cose che si vuole prendere in considerazione.

  1. La modifica della versione di una DLL di riferimento deve essere considerata una modifica inattesa.
  2. rimozione/modifica membri interrompe la compatibilità all'indietro.
  3. membri aggiungendo rompe la compatibilità in avanti (alcune persone considerano come sicuro 'membri aggiunti', ma ha un rischio associato).
  4. versione del file cambiare ad ogni generazione, sarà necessario che a un certo punto.
  5. Considera di scrivere contratti che definiscono la tua "API pubblica". Questi saranno i membri che è necessario supportare al di fuori dell'organizzazione. Pensa a loro come a confini di interoperabilità. Quindi consente alle classi di implementazione di avere membri pubblici, che non sono nell'API (quindi considerati "non supportati"), quindi è possibile cambiarli senza preoccuparsi di rompere l'API di estensibilità. Estendere l'API consiste di scrivere una nuova interfaccia (con un numero di versione nel nome dell'interfaccia), che non deriva dalla versione precedente di interfaccia (derivazione vi impedisce di membri a pieno di disapprovazione, e crea l'inferno quando arriva il momento di realizzare versioni di interfaccia multipli in una singola classe.
  6. non dimenticare gli attributi, le modifiche al loro non possono rompere la compatibilità statica, ma potrebbe influenzare il tempo di esecuzione.
+0

Elaborato su # 1? Che cosa succede se il mio Apple.dll dipende dalla v1 di Bear.dll e aggiorno alla v1.2 di Bear.dll e verificare che Bear.dll non esponga alcuna modifica di interruzione come per gli altri # 2-6? Gli utenti di Apple.dll non dovrebbero provare alcuna rottura come risultato corretto? Finché assicuro che tutti i dll di riferimento soddisfino anche gli stessi criteri lungo la catena ogni volta che aggiorno una DLL referenziata, non dovrebbe esserci un problema corretto? – AaronLS

+0

Ciao AaronLS. Questa è una buona domanda e dovrei aver originariamente elaborato al punto # 1. Il rischio insorge se la funzionalità pubblica di Apple.dll restituisce tipi che sono dichiarati all'interno di Bear.dll. Se questi assembly sono fortemente tipizzati, un prodotto che dipende da Apple si aspetta che la chiamata di funzione restituisca (nome di tipo completo) "Type, Bear, v1.1". Se hai "hot fix" (cambiato ma non invertito) sul tuo Apple.dll, ora restituirà "Type, Bear, v1.2" e il runtime genererà un'eccezione cast di classe - poiché i tipi con il nome sicuro sono qualificati da tutti componenti del nome, inclusa la versione. – Adam

3

Test unitari. Forniscono un modo per affermare "questo è ciò che il codice client si aspetta". Puoi costruire have TFS run unit tests durante la costruzione.

+3

Due preoccupazioni qui (e io sono un grande sostenitore dei test unitari!) Il per prima cosa dovresti avere una copertura del 100%, applicata per convenzione. Il secondo è che, a meno che i test non venissero mantenuti al di fuori della soluzione, qualsiasi refattore di rottura cambierebbe anche i test unitari, ignorando così il problema. – jalbert

2

Patrick Smacchia della fama di NDepend pubblicato circa questo ~ 3,5 anni fa.

http://codebetter.com/patricksmacchia/2008/01/20/avoid-api-breaking-changes/

egli cita LibCheck e (ovviamente) NDepend, ed un commento cita un altro.

Dal momento che sono passati più di 3,5 anni, ci potrebbero essere opzioni migliori disponibili in questi giorni (LibCheck ha ben più di 6 anni), ma quelle dovrebbero essere un inizio.

5

Elaborare un po 'sul James e Adam risposte, I' Mi piacerebbe fornire dettagli riguardanti rilevando il cambio di rottura s con NDepend e la sua query di codice e capacità di regola. Disclaimer: Sono uno degli sviluppatori dello strumento

NDepend si è evoluto e il suo linguaggio di query pure.Se scarichi la prova e l'analisi NDepend delle due versioni della tua base di codice in cui desideri effettuare la ricerca di modifiche di rottura, dai un'occhiata al gruppo di regole di codice predefinito API Breaking Changes per il seguente numero CQLinq rules.

L'esecuzione di uno di questi regola codice è simile, per esempio (diff tra NUnit v2.5.8 e V2.5.3):

API breaking changes