Modellazione di reti e rappresentazioni di entità permanenti

Ho un'app in cui ho bisogno di sincronizzare alcune entità (è sufficiente scaricare le ultime versioni delle entità dal server al client). Entity ha un sacco di proprietà del testo e un mucchio di link di risorse (referenziati da id, URL, qualunque cosa). Ad esempio, Entity ha tre proprietà:

id: integer,
name: string,
photos: array of photo ids

Per ora Entity è rappresentato da due classi: una per archivio persistente (sto usando CoreData spazio di archiviazione in iOS, potresti considerarlo come ORM se non hai familiarità con iOS SDK) e uno per l'analisi e l'analisi JSON serializzazione chiamata Entity e JSONEntity rispettivamente.

Entity

id: integer,
name: string,
photos: array of paths for files at local file system
pendingDownloads: object to track pending file downloads for 'Entity'

JSONEntity

id: integer,
name: string,
photos: array of photo ids

Utilizzerò il seguente algoritmo:

1. API del server di chiamata e ottieni una matrice di istanze di JSONEntity
2. per ogni% co_de recuperato
   1. trova o crea un'istanza corrispondente di JSONEntity che deve essere aggiornata
   2. aggiorna immediatamente la proprietà Entity di name istanza
   3. associa Entity istanza con l'attuale pendingDownloads istanza

% istanza diEntity che ha associato Entity oggetto è considerato come download e non può essere utilizzato.

All'avvio dell'applicazione:

1. trova pendingDownloads istanze con% non nullo% co_de
2. per ogni Entity in pendingDownloads
   1. scarica foto
   2. aggiungi il riferimento al file locale alla foto in id
   3. rimuovi l'elemento corrente da pendingDownloads
3. null-out photos proprietà
4. notifica al modello che pendingDownloads ha terminato la sincronizzazione [/ li>

Per quanto mi riguarda, il più grande difetto dell'attuale approccio è che devo mantenere due gerarchie parallele di classi: una per l'archivio persistente e una per l'analisi / serializzazione JSON.

Ho provato a utilizzare l'ereditarietà: ho dichiarato proprietà sottoclasse di livello newtork (come foto) in superclasse e livello locale (come i riferimenti ai file) nella sottoclasse. Ma non mi piace nemmeno questo approccio - l'oggetto si carica di responsabilità - deve tracciare sia le informazioni a livello di rete che quelle a livello locale.

Esistono schemi o approcci per gestire questo tipo di situazioni? Sarei grato per ogni pensiero.

Grazie.