Como criar corretamente um novo Produtor?

Question

Estou usando a ferramenta de modelo de objeto orientado CodeFluentEntidades para implantar um modelo em um mecanismo de banco de dados.

Estou pensando em usar mecanismos de banco de dados localStorage (como IndexedDB ou Web SQL) para armazenar meus dados para um aplicativo Web sem servidor.

Eu olhei para o documentação mas me parece um pouco pobre...Acho que entendi os princípios básicos como os pontos de injeção que são Produce() e Terminate() mas e o diretório de destino da produção real?

No meu caso, que são arquivos de código-fonte Javascript, como posso especificar corretamente (de forma referenciada) onde gerá-los?E tem que estar em um projeto externo, ou posso apenas preencher um diretório em outro projeto (que é o .vsproj do meu webapp, por exemplo)?

A documentação pode integrar uma amostra de código sobre esses aspectos, ou alguém pode me redirecionar para um artigo que atenda às minhas necessidades?

Answer 1

A abordagem do modelo

De acordo com sua necessidade, sugiro que você utilize um template em vez de desenvolver seu Produtor customizado por, entre outros, motivos de implantação.Usando o produtor de modelo (fornecido com CodeFluent Entities), você pode criar scripts complexos de forma rápida e fácil, aproveitando as vantagens do metamodelo CodeFluent Entities.

Este produtor é baseado no mecanismo de template do CodeFluent Entities e permite gerar arquivos de texto (JavaScript no seu caso) no momento da produção.Como lembrete, um modelo é simplesmente uma mistura de blocos de texto e lógica de controle que pode gerar um arquivo de saída

Este produtor cuida de todas as operações comuns:atualize o projeto (.XXproj) para adicionar os arquivos gerados, adicionar referências ausentes, etc.Você pode encontrar a seguir um exemplo para gerar um arquivo de script IndexDB baseado em um modelo CodeFluent Entities (apenas para fins de demonstração).Aqui está o arquivo fonte do modelo:

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

Então você precisa configurar seu projeto de entidades CodeFluent adicionando o Template Producer e definir o modelo acima como o arquivo de origem.

Se você considerar o seguinte modelo:

Basta construí-lo para gerar o arquivo de script IndexDB no projeto de destino (uma aplicação web, por exemplo) e você poderá manipular a API gerada assim:

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

A abordagem personalizada do produtor

No entanto, se alguma vez você precisar direcionar uma tecnologia ou plataforma que não seja suportada nativamente por CodeFluent Entities, você pode criar seu próprio produtor personalizado implementando a interface IProducer:

public interface IProducer
{
    event Producer.OnProductionEventHandler Production;

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

Primeiro de tudo, você precisa entender que o mecanismo CodeFluent Entitie Build chama cada um dos seus produtores configurados, um por um, para gerar seu código.

Em primeiro lugar, CodeFluent Entities chama o Initialize método para cada produtor.Toma como parâmetro uma instância do projeto CodeFluent Entities e o produtor atual.Então ele chama o Product método seguindo o mesmo processo.É o lugar certo para implementar sua lógica de geração.Finalmente, você poderia implementar uma lógica de finalização no Terminate método.

CodeFluent fornece algumas classes base que implementam a interface IProducer, como BaseProducer, que está localizada no assembly CodeFluent.Producers.CodeDom que fornece comportamentos como "adicionar referências ausentes" ou "atualizar projeto do Visual Studio (.XXproj).

Além disso, aqui está um postagem no blog que pode ajudá-lo a integrar um produtor personalizado ao modelador.

A abordagem do subprodutor

Uma outra abordagem poderia ser desenvolver um Subprodutor personalizado mas, na minha opinião, não é adequado às suas necessidades.