Comment bien créer un nouveau Producteur ?

Question

J'utilise l'outil de modèle d'objet piloté CodeFluentEntités afin de déployer un modèle sur un moteur DataBase.

Je pense utiliser des moteurs de base de données localStorage (comme IndexedDB ou Web SQL) afin de stocker mes données pour une application web sans serveur.

J'ai regardé dans le Documentation mais ça me semble un peu pauvre...Je pense avoir compris les principes de base comme les points d'injection qui sont Produce() et Terminate() mais qu'en est-il du répertoire cible de la production réelle ?

Dans mon cas, qui concerne les fichiers de code source Javascript, comment spécifier correctement (de manière référencée) où les générer ?Et est-ce que cela doit être dans un projet externe, ou pourrais-je simplement remplir un répertoire dans un autre projet (qui est le .vsproj de ma webapp, par exemple) ?

La documentation peut-elle intégrer un échantillon de code concernant ces aspects, ou quelqu'un peut-il me rediriger vers un article correspondant à mes besoins ?

Answer 1

L'approche modèle

Selon vos besoins, je vous suggère d'utiliser un modèle au lieu de développer votre Producer personnalisé pour des raisons, entre autres, de déploiement.À l'aide du producteur de modèles (livré avec CodeFluent Entities), vous pouvez créer rapidement et facilement des scripts complexes en tirant parti du méta-modèle CodeFluent Entities.

Ce producteur est basé sur le moteur de template de CodeFluent Entities et vous permet de générer des fichiers texte (JavaScript dans votre cas) au moment de la production.Pour rappel, un modèle est simplement un mélange de blocs de texte et de logiques de contrôle pouvant générer un fichier de sortie.

Ce producteur s'occupe de toutes les opérations courantes :mettez à jour le projet (.XXproj) pour ajouter vos fichiers générés, ajouter les références manquantes, etc.Vous trouverez ci-après un exemple pour générer un fichier script IndexDB basé sur un modèle CodeFluent Entities (à des fins de démonstration uniquement).Voici le fichier source du modèle :

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

Ensuite, vous devez configurer votre projet CodeFluent Entities en ajoutant le producteur de modèles et définir le modèle ci-dessus comme fichier source.

Si l'on considère le modèle suivant :

Construisez-le simplement pour générer le fichier script IndexDB dans le projet cible (une application web par exemple) et vous pourrez manipuler l'API générée comme ceci :

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’approche Producteur sur mesure

Néanmoins, si jamais vous avez besoin de cibler une technologie ou une plateforme qui n'est pas supportée nativement par CodeFluent Entities, vous pouvez créer votre propre producteur personnalisé en implémentant l'interface IProducer :

public interface IProducer
{
    event Producer.OnProductionEventHandler Production;

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

Tout d'abord, vous devez comprendre que le moteur CodeFluent Entitie Build appelle chacun de vos producteurs configurés un par un pour générer votre code.

Premièrement, CodeFluent Entities appelle le Initialize méthode pour chaque producteur.Il prend en paramètre une instance du projet CodeFluent Entities et le producteur actuel.Puis il appelle le Product méthode suivant le même processus.C'est le bon endroit pour mettre en œuvre votre logique de génération.Enfin, vous pouvez implémenter une logique de finalisation dans le Terminate méthode.

CodeFluent fournit certaines classes de base qui implémentent l'interface IProducer, telles que BaseProducer qui se trouve dans l'assembly CodeFluent.Producers.CodeDom qui fournit des comportements tels que « ajouter des références manquantes » ou « mettre à jour le projet Visual Studio (.XXproj).

De plus, voici un article de blog cela peut vous aider à intégrer un producteur personnalisé au modeleur.

L’approche Sous-Producteur

Une autre approche pourrait consister à développer un Sous-producteur personnalisé mais, à mon avis, cela ne convient pas à vos besoins.