Come creare correttamente un nuovo produttore?

Question

Sto usando lo strumento del modello oggetto guidato Codefluententicità per distribuire un modello in un motore di database .

Sto pensando di utilizzare i motori del database di localstorage (come IndexedDB o Web SQL) per memorizzare i miei dati per un'applicazione Web senza server.

Ho guardato in Documentazione ma mi sembra un po 'poveri ... Penso di aver capito i principi di base come i punti di iniezione che sono Produce() e Terminate() ma per quanto riguarda la directory di destinazione della produzione effettiva?

Nel mio caso, che è file di codice sorgente JavaScript, come posso specificare correttamente (in modo referenziato) dove generarli? E deve essere in un progetto esterno o potrei semplicemente riempire una directory in un altro progetto (che è il .vsproj del mio webapp, per esempio)?

La documentazione può integrare un campione di codice relativo a questi aspetti, o qualcuno può reindirizzarmi a un articolo che raccoglie le mie esigenze?

Answer 1

L'approccio del modello

Secondo le tue esigenze, ti suggerisco di utilizzare un modello invece di sviluppare il tuo produttore personalizzato a causa di, tra gli altri, motivi di distribuzione. Utilizzando il produttore del modello (spedito con entità codifluent) È possibile creare rapidamente e facilmente gli script complessi sfruttando le entità codifluenti Meta Model.

Questo produttore si basa sul motore dei modelli delle entità codifluent e consente di generare file di testo (JavaScript nel tuo caso) al tempo di produzione. Come promemoria, un modello è semplicemente una miscela di blocchi di testo e la logica di controllo che può generare un file di output

Questo produttore si occupa di tutte le operazioni comuni: aggiorna il progetto (.xxProj) per aggiungere i tuoi file generati, aggiungere riferimenti mancanti, ecc. Puoi trovare successivamente un esempio per generare un file di script indexdb in base a un modello di entità codifluent (solo scopi dimostrativi). Ecco il file sorgente del modello:

[%@ reference name="C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Core.dll" %]
[%@ namespace name="System" %]
[%@ namespace name="System.Linq" %]
[%@ namespace name="CodeFluent.Model" %]

var context = {};
context.indexedDB = {};
context.indexedDB.db = null;

context.indexedDB.open = function () {
    var version = 11;
    var request = indexedDB.open([%=Producer.Project.DefaultNamespace%], version);

    request.onupgradeneeded = function (e) {
        var db = e.target.result;
        e.target.transaction.onerror = context.indexedDB.onerror;
        [%foreach(Entity entity in Producer.Project.Entities){
            string properties = String.Join(", ", entity.Properties.Where(p => !p.IsPersistenceIdentity).Select(p => "\"" + p.Name + "\""));
        %]
        if (db.objectStoreNames.contains("[%=entity.Name%]")) {
            db.deleteObjectStore("[%=entity.Name%]"); 
        }

        var store = db.createObjectStore("[%=entity.Name%]",
          { keyPath: "id", autoIncrement: true });

        store.createIndex([%=properties %], { unique: false });[%}%]
    };

    request.onsuccess = function (e) {
        context.indexedDB.db = e.target.result;
    };

    request.onerror = context.indexedDB.onerror;
};
    [%foreach(Entity entity in Producer.Project.Entities){
        string parameters = String.Join(", ", entity.Properties.Where(p => !p.IsPersistenceIdentity).Select(p => p.Name));%]
context.indexedDB.[%=entity.Name%] = {}

    context.indexedDB.[%=entity.Name%].add = function ([%= parameters %]) {
    var db = context.indexedDB.db;
    var trans = db.transaction(["[%=entity.Name%]"], "readwrite");
    var store = trans.objectStore("[%=entity.Name%]");
    var request = store.put({
    [% 
        foreach (Property property in entity.Properties.Where(p => !p.IsPersistenceIdentity)) {%]
        "[%=property.Name%]": [%=property.Name%], [%}%]
        "timeStamp": new Date().getTime()
    });

    request.onsuccess = function (e) {
        console.log(e.value);
    };

    request.onerror = function (e) {
        console.log(e.value);
    };
};

context.indexedDB.[%=entity.Name%].delete = function (id) {
    var db = context.indexedDB.db;
    var trans = db.transaction(["[%=entity.Name%]"], "readwrite");
    var store = trans.objectStore("[%=entity.Name%]");

    var request = store.delete(id);

    request.onsuccess = function (e) {
        console.log(e);
    };

    request.onerror = function (e) {
        console.log(e);
    };
};

context.indexedDB.[%=entity.Name%].loadAll = function () {
    var db = context.indexedDB.db;
    var trans = db.transaction(["[%=entity.Name%]"], "readwrite");
    var store = trans.objectStore("[%=entity.Name%]");

    var keyRange = IDBKeyRange.lowerBound(0);
    var cursorRequest = store.openCursor(keyRange);

    request.onsuccess = function (e) {
        // not implemented
    };

    request.onerror = function (e) {
        console.log(e);
    };
};
[%}%]

function init() {
    context.indexedDB.open(); // initialize the IndexDB context.
}

window.addEventListener("DOMContentLoaded", init, false);

.

Quindi è necessario configurare il progetto di entità CodeFluent aggiungendo il produttore del modello e definisci il modello sopra come file sorgente.

Se si considera il seguente modello:

Basta costruiscilo per generare il file di script indexdb nel progetto di destinazione (ad esempio un'applicazione Web) e sarai in grado di manipolare l'API generata come questa:

context.indexedDB.Contact.add("Peter", "Boby")
context.indexedDB.Product.add("Tablet")
context.indexedDB.Product.add("Computer")
context.indexedDB.Contact.delete(1)
context.indexedDB.Product.loadAll()

.

L'approccio del produttore personalizzato

Tuttavia, se mai è necessario indirizzare una tecnologia o una piattaforma supportata da entità codifluenti nativamente, è possibile creare il proprio produttore personalizzato implementando l'interfaccia IPRODUCER:

public interface IProducer
{
    event Producer.OnProductionEventHandler Production;

    void Initialize(Project project, Producer producer);
    void Produce();
    void Terminate();
}

.

Prima di tutto, è necessario comprendere che il codefluent Entitie Build Engine chiama ciascuno dei tuoi produttori configurati uno per uno per generare il codice.

Prima, le entità codifluenti chiama il metodo Initialize per ciascun produttore. Ci vuole come parametro un'istanza del progetto di entità CodeFluent e il produttore corrente. Quindi chiama il metodo Product seguendo lo stesso processo. È il posto giusto per implementare la logica della tua generazione. Infine, è possibile implementare una logica finalizzata nel metodo Terminate.

Codefluent fornisce alcune classi di base che implementano l'interfaccia IPRODUCER come BASEPRODUCER che si trova in CodeFluent.produceri.Codedom Assembly che fornisce comportamenti come "Aggiungi riferimenti mancanti" o "Aggiorna il progetto di Visual Studio (Aggiorna il progetto (.xxproj).

Inoltre, ecco un Blog Post che può aiutarti a integrare un produttore personalizzato al modellatore.

L'approccio del sub-produttore

Un altro approccio potrebbe essere quello di sviluppare un sub-produttore personalizzato ma, in La mia opinione, non è adatta in base alle tue esigenze.