Wie erstellt man richtig einen neuen Produzenten?

Question

Ich verwende das angetriebene Objektmodell-Tool CodeFluentEntities um ein Modell auf einer Datenbank-Engine bereitzustellen.

Ich denke darüber nach, localStorage-Datenbank-Engines (wie IndexedDB oder Web SQL) zu verwenden, um meine Daten für eine Webanwendung ohne Server zu speichern.

Ich habe in das geschaut Dokumentation aber es kommt mir etwas dürftig vor...Ich glaube, ich habe die Grundprinzipien wie die Einspritzpunkte verstanden Produce() Und Terminate() aber was ist mit dem Zielverzeichnis der eigentlichen Produktion?

Wie kann ich in meinem Fall, bei dem es sich um Javascript-Quellcodedateien handelt, korrekt (in referenzierter Weise) angeben, wo sie generiert werden sollen?Und muss es sich in einem externen Projekt befinden, oder könnte ich einfach ein Verzeichnis in einem anderen Projekt füllen (das ist beispielsweise die .vsproj-Datei meiner Webanwendung)?

Kann die Dokumentation ein Beispielcode zu diesen Aspekten integrieren, oder kann mich jemand zu einem Artikel weiterleiten, der meinen Bedürfnissen entspricht?

Answer 1

Der Template-Ansatz

Je nach Bedarf empfehle ich Ihnen, eine Vorlage zu verwenden, anstatt Ihren benutzerdefinierten Produzenten zu entwickeln, unter anderem aus Gründen der Bereitstellung.Mit dem Vorlagenproduzenten (im Lieferumfang von CodeFluent Entities enthalten) können Sie schnell und einfach komplexe Skripte erstellen, indem Sie die Vorteile des CodeFluent Entities-Metamodells nutzen.

Dieser Producer basiert auf der Template-Engine von CodeFluent Entities und ermöglicht Ihnen die Generierung von Textdateien (in Ihrem Fall JavaScript) zur Produktionszeit.Zur Erinnerung: Eine Vorlage ist einfach eine Mischung aus Textblöcken und Steuerlogik, die eine Ausgabedatei generieren kann

Dieser Produzent kümmert sich um alle gängigen Vorgänge:Aktualisieren Sie das Projekt (.XXproj), um Ihre generierten Dateien hinzuzufügen, fehlende Referenzen hinzuzufügen usw.Nachfolgend finden Sie ein Beispiel zum Generieren einer IndexDB-Skriptdatei basierend auf einem CodeFluent-Entities-Modell (nur zu Demonstrationszwecken).Hier ist die Vorlagenquelldatei:

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

Anschließend müssen Sie Ihr CodeFluent Entities-Projekt konfigurieren, indem Sie den Vorlagenersteller hinzufügen und die obige Vorlage als Quelldatei definieren.

Wenn Sie das folgende Modell in Betracht ziehen:

Erstellen Sie es einfach, um die IndexDB-Skriptdatei im Zielprojekt (z. B. einer Webanwendung) zu generieren, und Sie können die generierte API wie folgt bearbeiten:

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

Der benutzerdefinierte Producer-Ansatz

Sollten Sie jedoch jemals auf eine Technologie oder Plattform abzielen müssen, die von CodeFluent Entities nicht nativ unterstützt wird, können Sie Ihren eigenen benutzerdefinierten Produzenten erstellen, indem Sie die IProducer-Schnittstelle implementieren:

public interface IProducer
{
    event Producer.OnProductionEventHandler Production;

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

Zunächst müssen Sie verstehen, dass die CodeFluent Entitie Build-Engine jeden Ihrer konfigurierten Produzenten einzeln aufruft, um Ihren Code zu generieren.

Erstens ruft CodeFluent Entities das auf Initialize Methode für jeden Hersteller.Als Parameter werden eine Instanz des CodeFluent Entities-Projekts und der aktuelle Produzent verwendet.Dann ruft es das auf Product Methode, die dem gleichen Prozess folgt.Es ist der richtige Ort, um Ihre Generierungslogik zu implementieren.Schließlich könnten Sie eine Finalisierungslogik in implementieren Terminate Methode.

CodeFluent stellt einige Basisklassen bereit, die die IProducer-Schnittstelle implementieren, z. B. BaseProducer, das sich in der CodeFluent.Producers.CodeDom-Assembly befindet und Verhaltensweisen wie „Fehlende Referenzen hinzufügen“ oder „Visual Studio-Projekt (.XXproj) aktualisieren“ bereitstellt.

Darüber hinaus gibt es hier eine Blogeintrag Dies kann Ihnen dabei helfen, einen benutzerdefinierten Produzenten in den Modellierer zu integrieren.

Der Subproduzenten-Ansatz

Ein anderer Ansatz könnte darin bestehen, eine zu entwickeln benutzerdefinierter Subproduzent aber meiner Meinung nach ist es nicht für Ihre Bedürfnisse geeignet.