EPLAN-API

Jeder der in der EPLAN API programmiert, kennt die Aufwände beim Locking. Es ist mir nicht immer ganz klar wann was zu verwenden ist. LockingVector sollte nur in Ausnahmefällen verwendet werden, es kann zu unschönen Verhalten kommen. Auch so in der API-Hilfe beschrieben.

Der LockingVector hebelt das Locking komplett aus und die API verhält sich ähnlich wie die Oberfläche. Hört sich gut an, aber wie gesagt für mich nur mit Vorsicht zu genießen.

Dennoch gibt es für mich einen Anwendungsfall: Interne EPLAN Action im API ausführen… Ja manchmal muss man das. Hatte mit Auswertungen aktualisieren den Fall:

LockingVector lockingVector = new LockingVector();
int manualLockStateId = lockingVector.PauseManualLock();

new CommandLineInterpreter().Execute("XFgUpdateEvaluationAction");

lockingVector.ResumeManualLock(manualLockStateId);

Wichtig ist dass ResumeManualLock()  nicht vergessen wird… Ich hab mir das mal in ein Using gepackt, das sich um alles kümmert und auch die Klasse auf GitHub bereitgestellt:

using (new LockingUtility.SeplaLockingVector())
{
  new CommandLineInterpreter().Execute("XFgUpdateEvaluationAction");
}

Schnell mal per API Artikel mit Funktionsschablone erzeugen war meine Aufgabe…
Naja nicht so einfach:

public static MDPart CreateOrUpdateWithFunctionTemplate(Function function)
{
    // Need to lock project
    var project = function.Project;
    project.SmartLock();
    function.SmartLock();

    // Init
    var partsDatabase = new MDPartsManagement().OpenDatabase();
    var articleReference = function.ArticleReferences.First();
    articleReference.SmartLock();
    var partNr = articleReference.PartNr;
    var partVariant = articleReference.VariantNr;
    MDPart part = partsDatabase.GetPart(partNr, partVariant);

    // Create new part
    if (part == null)
    {
        // LockingVector is needed because of locking exception from EPLAN action (no catch possible)
        LockingVector lockingVector = new LockingVector();
        int stateId = lockingVector.PauseManualLock();
        new CommandLineInterpreter().Execute("XPameCreateType");
        lockingVector.ResumeManualLock(stateId);

        partsDatabase = new MDPartsManagement().OpenDatabase(); // Second Call needed to get new part
        part = partsDatabase.GetPart(partNr, partVariant);                
    }
    else
    {
        // Rename part
        string suffix = "_temp";
        string partNrTemp = part.PartNr + suffix;
        try
        {
            articleReference.PartNr = partNrTemp;
            articleReference.StoreToObject();

            // Quiet create temp part
            var application = new EplApplication();
            var quiteMode = application.QuietMode;
            application.QuietMode = EplApplication.QuietModes.ShowNoDialogs;
            new CommandLineInterpreter().Execute("XPameCreateType");
            application.QuietMode = quiteMode;
        }
        finally
        {
            // Rename back
            articleReference.PartNr = partNr;
            articleReference.StoreToObject();
        }

        // Copy FunctionTemplate
        partsDatabase = new MDPartsManagement().OpenDatabase(); // Second Call needed to get new part
        MDPart partDuplicate = partsDatabase.GetPart(partNrTemp, partVariant);
        foreach (var partFunctionTemplatePosition in part.FunctionTemplatePositions)
        {
            part.RemoveFunctionTemplatePosition(partFunctionTemplatePosition);
        }
        foreach (var partDuplicateFunctionTemplatePosition in partDuplicate.FunctionTemplatePositions)
        {
            part.AddFunctionTemplatePosition(partDuplicateFunctionTemplatePosition);
        }

        partsDatabase.RemovePart(partDuplicate);


        // Check if article is in project
        var existingArticle = project.Articles
            .FirstOrDefault(obj =>
            obj.PartNr.Equals(partNrTemp) && obj.VariantNr.Equals(partVariant)
            );
        if (existingArticle != null)
        {
            existingArticle.SmartLock();
            existingArticle.Remove();
        }
    }

    // Load data
    var article = project.Articles
        .FirstOrDefault(obj =>
            obj.PartNr.Equals(partNr) && obj.VariantNr.Equals(partVariant)
        );
    if (article != null)
    {
        article.SmartLock();
        article.LoadFromMasterdata();
    }

    return part;
}

Es darf nur ein Artikel hinterlegt sein, sonst schlägt die Action XPameCreateType  fehl. Ist nicht schön, aber die Funktionsschablone von Hand zu erstellen ist mir zu heikel. Denn da kommt ja oftmals was neues dazu :^)

Man ist es gewohnt über Bearbeiten Rückgängig  zu arbeiten…
Aber das geht nicht von alleine, mann muss schon was dafür tun.

EPLAN stellt hier zwei Klassen bereit, welche das sehr gut implementieren. Muss sagen ich nutze für Schreiboperationen (ab sofort) immer Beide.
UndoStep lässt den User die Möglichkeit die Bearbeitung per API rückgängig zu machen. SafetyPoint stellt den Ursprung wieder her, falls eine Exception auftritt.

Toller Nebeneffekt, man muss sich nicht ums Locking der erzeugten Elemente kümmern :)

public void DoStuff()
{
    using (var undoStep = new UndoManager().CreateUndoStep())
    {
        undoStep.SetUndoDescription("DoStuff");
        using (SafetyPoint safetyPoint = SafetyPoint.Create())
        {
            try
            {
                // Do wild stuff
                safetyPoint.Commit();
            }
            catch (Exception exception)
            {
                MessageBox.Show(exception.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                safetyPoint.Rollback();
            }
        }
    }
}

Die EPLAN API Hilfe ist ja nun Online verfügbar. Aber die Seite braucht ewig zum laden, warum weiß ich leider nicht. Vielleicht kann jemand von EPLAN hier ein Statement schreiben.
Um schnell etwas zu suchen nutze ich diese URL und öffne die Ergebnisse in einem neuen Fenster.

Und täglich grüßt die EPLAN Signierung…

Meine Beschreibung hier, klappt leider nur wenn man eine DLL bzw. EXE hat. Es wird zwar alles richtig signiert, aber die Verweise werden nicht aktualisiert, da ist .NET schuld…

Tja, für die Meisten wird das kein Problem sein, aber ich arbeite immer mit verteilten Libraries.

Ich habe einen Weg gefunden der für mich OK ist. Bisl manuelle Arbeit hat man wenn man mehrere Keys signieren muss.
In der AssemblyInfo.cs  lege ich fest dass in der Release Konfiguration die Kompiler-Attribute für EPLAN gesetzt werden.

// EPLAN signing
#if TRACE && !DEBUG
using Eplan.EplApi.Starter;
[assembly: EplanSignedAssembly(true)]
[assembly: AssemblyKeyFile("2161_Public.snk")]
[assembly: AssemblyDelaySign(true)]
#endif

Das tolle ist, ich kann nach wie vor den Release Build testen, wenn ich das Trace Flag wegnehme.

Zusätzlich wird die Signierung wirklich erst von EPLAN gemacht… denn die Attribute reservieren nur den Speicher in den Assemblies. Somit kann man auch Extensions verwenden welche den Build beeinflussen wie Fody.PropertyChanged, welches bei mir immer mit WPF im Einsatz ist.

Mir ist beim Bauen einer Offline-Application auch noch was aufgefallen:
Werden externe Assemblies verwendet, achtet darauf das diese strong namend signiert sind. Sonst könnt Ihr Sie nicht verwenden. Ich nutze zum Glück ausschließlich OpenSource Lösungen… denn eine davon war nicht signiert und ich musste es dann mit dem EPLAN KeyFile selbst machen, was ich ja konnte da Code vorhanden ist :^)

Vielen Dank an der Stelle, mal wieder, an den tollen EPLAN API Support, der mir hier wieder freundlich zur Seite stand!