Breeze: Come posso creare una chiave GUID per le nuove entità sul client?

Question

Utilizzo di Breeze, qual è il modo più semplice per popolare una chiave GUID quando viene creata un'entità?

Answer 1

Suppongo che l'entità sia configurata in modo tale che il client sia responsabile dell'impostazione del codice guida per le nuove entità. Questo è il valore predefinito per il tasto Guida di un'entità Entity Framework First Code; è come se la proprietà chiave sono stati ornati con [DatabaseGenerated(DatabaseGeneratedOption.None)]

L'approccio più ovvio è quello di impostare la chiave dopo aver creato l'entità e la prima di aggiungerlo al gestore, ad esempio:

 
function createFoo() { 
    var foo = fooType.createEntity(); 
    foo.id(breeze.core.getUuid()); // Knockout implementation 
    manager.addEntity(foo); 
} 

Questo può essere tutto ciò che mai bisogno.

D'altra parte, si potrebbe scoprire che si sta creando nuova Foos in molti luoghi e per qualche strana ragione non è possibile utilizzare la funzione createFoo. Certamente non vuoi ripetere quel codice.

è possibile estendere il tipo Foo entità con un comportamento id-regolazione dopo il quale si sarebbe in grado di scrivere:

 
function createFoo() { 
    var foo = fooType.createEntity(); // foo.id is set for you 
    manager.addEntity(foo); 
} 

Ci sono due approcci da considerare - costruttore personalizzato e inizializzatore di tipo; entrambi sono descritti in "Extending Entities"

Constructor

È possibile inizializzare la chiave all'interno di un costruttore personalizzato. Breeze chiama il costruttore sia quando crei l'entità sia quando materializza un'entità interrogata. Breeze sostituirà il valore chiave iniziale quando si materializza.

Ecco un esempio che presuppone la libreria di modelli Knockout.

 
function Foo() { 
    foo.id(breeze.core.getUuid()); // using KO 
} 

// one way to get the MetadataStore 
var store = manager.metadataStore; 
// register the ctor with the Foo type 
store.registerEntityTypeCtor("Foo", Foo); 

Abbastanza semplice. L'unico lato negativo è che Breeze genererà un Guid ogni volta che crea un'entità, sia che ne crei una nuova sia che ne materializzi una da una query. È uno sforzo inutile durante la materializzazione, ma allora? Bene, suppongo che diventi un problema di prestazioni anche se non lo assumerei finché non l'avessi misurato.

Initializer

Supponiamo di misurata e la generazione Guid ripetuto è un problema serio (davvero?). Puoi invece impostare la chiave in un inizializzatore di tipo e chiamare il generatore Guid solo quando crei una nuova entità.

Breeze chiama un inizializzatore di tipo dopo l' l'entità è stata creata o materializzata dalla query appena prima di restituire tale entità all'applicazione. Chiaramente non si desidera sovrascrivere una chiave materializzata dal database in modo da testare il valore della chiave per assicurarsi che non sia reale (ovvero per assicurarsi di correggere un'entità creata) prima di assegnarla. Ecco un esempio.

 
function fooInitializer(foo) { 
    var emptyGuid = "00000000-0000-0000-0000-000000000000"; 
    if (foo.id() !=== emptyGuid) { 
     foo.id(breeze.core.getUuid()); 
    } 
} 

var store = manager.metadataStore; 
// register the initializer; no ctor in this example 
store.registerEntityTypeCtor("Foo", function(){}, fooInitializer); 

Answer 2

Supponendo di avere una chiave surrogata Guid su tutti i soggetti, come abbiamo nel nostro caso, è possibile codificare una fabbrica createInstance che fa quanto segue in un approccio molto generica:

function createInstance(breezeEntityManager, typeName) { 
    var keyProperty = breezeEntityManager.metadataStore.getEntityType(typeName, false).dataProperties.filter(function (p) { 
     return p.isPartOfKey; 
    })[0]; 
    var config = {}; 
    config[keyProperty.name] = breeze.core.getUuid(); 
    return breezeEntityManager.createEntity(typeName, config); 
} 

In questo modo , non dovrai creare un inizializzatore per tutte le tue entità.