Cómo crear correctamente un nuevo Productor?

Question

Estoy usando el modelo de objetos de la herramienta CodeFluentEntities con el fin de implementar un modelo de un motor de Base de datos.

Estoy pensando en usar localStorage motores de base de datos (como IndexedDB o Web SQL) para almacenar mis datos para una aplicación web sin necesidad de servidor.

Miré en la documentación pero a mí me parece un poco pobre...Creo que he entendido los principios básicos como los puntos de inyección que son Produce() y Terminate() pero, ¿y el directorio de destino de la producción real ?

En mi caso, que es Javascript archivos de código fuente, ¿cómo puedo especificar correctamente (en la que se hace referencia manera) donde a generar ?Y tiene que ser en un proyecto externo, o podría simplemente llenar un directorio en otro proyecto (que es el .vsproj de mi aplicación web, por ejemplo) ?

Puede la documentación integrar un ejemplo de código con respecto a estos aspectos, o alguien puede redirigir a mí a un artículo de ajuste a mis necesidades ?

Answer 1

La Plantilla de enfoque

De acuerdo con sus necesidades, le sugiero que utilice una plantilla de desarrollo personalizado Productor debido a, entre otros, la implementación de razones.El uso de la plantilla de productor (se entregan con CodeFluent Entidades) usted puede rápida y fácilmente crear secuencias de comandos complejas tomando ventaja de la CodeFluent Entidades del modelo meta.

Este productor se basa en CodeFluent de las Entidades de la plantilla del motor y permiten generar archivos de texto (JavaScript en su caso) en el tiempo de producción.Como un recordatorio, Una plantilla es simplemente una mezcla de bloques de texto y de la lógica de control que puede generar un archivo de salida

Este productor se encarga de todas las operaciones comunes :actualizar el proyecto (.XXproj) para agregar sus archivos generados, agregar referencias que faltan, etc.Usted puede encontrar a partir de entonces un ejemplo para generar un IndexDB archivo de secuencia de comandos basado en un CodeFluent Entidades del modelo (fines de demostración).Aquí está la plantilla de archivo de origen :

[%@ 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);

Entonces usted necesita para configurar su CodeFluent Entidades del Proyecto mediante la adición de la Plantilla Productor y definir la plantilla de arriba como el archivo de origen.

Si se considera el siguiente modelo :

Acaba de construir para generar el IndexDB archivo de secuencia de comandos en el proyecto de destino (una aplicación web por ejemplo) y usted será capaz de manipular la API generada como este :

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()

La costumbre Productor de enfoque

Sin embargo, si alguna vez usted necesita para centrarse en una tecnología o plataforma que no es compatible con CodeFluent Entidades de forma nativa, usted puede crear su propio personalizado productor a través de la implementación de la IProducer interfaz :

public interface IProducer
{
    event Producer.OnProductionEventHandler Production;

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

Primero de todos, usted necesita entender que el CodeFluent Entitie motor de generación de llamadas de cada uno de sus configurado productores, uno por uno para generar el código.

En primer lugar, CodeFluent Entidades llamadas de la Initialize método para cada uno de los productores.Se toma como parámetro una instancia de la CodeFluent Entidades del proyecto y el actual productor.A continuación, llama a la Product método siguiendo el mismo proceso.Es el lugar adecuado para implementar la lógica de generación.Finalmente, se podría implementar un ultimar la lógica en la Terminate método.

CodeFluent proporciona cierta base de las clases que implementan la IProducer de la interfaz, tales como BaseProducer que se encuentra en CodeFluent.De los productores.CodeDom asamblea que proporciona conductas como "agregar referencias que faltan" o "actualización de proyecto de Visual Studio (.XXproj).

Además, he aquí una blog en que puede ayudar a integrar una costumbre productor para el modelador.

La Sub-Productor enfoque

Otro enfoque podría ser la elaboración de un personalizado Sub-Productor pero, en mi opinión, no es adecuado de acuerdo a sus necesidades.