Editor Aktualisierung unterdrücken

[zero]

Hi,

ich habe einen Editor Wizard mit VS2017 in C# erstellt, der mir automatisch Variablen abhängig von SPS Programmen erzeugt.
Vorher hatte ich ein ähnliches Makro in VBA.
Das Problem ist, dass der Code nun deutlich langsamer ist.
Ich meine damals hat sich der Editor im Hintergrund nicht aktualisiert und erst nach Abarbeitung die neuen Variablen aufgelistet.
Kann man das im AddIn vielleicht unterdrücken?
Es werden pro Steuerung durchschnittlich 15.000 Variabel erstellt/aktualisiert das dauer ca. 45min bis 50min. Bei 80 Steuerung ist das ein bisschen zu träge....

Gruß Tobias

[LukasRotter]

Hallo zero,

Ich gehe mal davon aus, dass die Variablen über Create() Aufrufe der VariableCollection erstellt werden.

Bei einer summierten Anzahl von über 1 Million Variablen, die erstellt/modifiziert werden müssen, würde ich definitiv einen programmatisch aufgerufenen XML Import anstatt von COM-Zugriffen empfehlen. Dieser Import ist weitaus performanter. Nachteil hierbei ist natürlich, dass der Wizard erweitert werden müsste, um valide XML Dateien zu generieren. Mit exportierten XML-Vorlagen sollte dies aber kein allzu großer Aufwand sein.

Dennoch kommen mir 50 Minuten für 15.000 Variablen selbst über COM unüblich lange vor. Die direkte Aktualisierung von Variablen im Editor konnte ich über Add-In auch nicht reproduzieren (außer Veränderungen der ScrollBar und Statusleiste).

Falls die XML-Methode inakzeptabel ist, wäre ein Ausschnitt vom Code, der die Variablen erzeugt, hilfreich zum reproduzieren.

Mir ist keine Möglichkeit bekannt, eine Deaktivierung von jeglichen Editor Aktualisierungen über API auszuschalten.

LG
Lukas

[zero]

Hi Lukas,

vielen Dank für die schnelle Antwort.

Gegen den Weg über einen XML Import spricht nichts, das hört sich nach einer guten Lösung an.
Ich lese Suchbegriffe und Eigenschaften von Variablen aus einer CSVdatei ein,
und durchsuche dann eine .Sym Datei welche alle Variabel des SPS Programms beinhaltet, um die zu finden die zu den Suchbegriffen passen.
Die Variablen werden dann zusammen mit den Eigenschaften (alles vortaufend) in einer Liste gespeichert und dann an das Programm übergeben welches die Variablen erstellt.

Anbei mal der Code

public VariablenAnlegen(IEditorApplication context, List Var, int k)
        {
            try
            {
                if (context != null)
                {
                    m_context = context;
                }
                else
                {
                    System.Diagnostics.Debug.Print("Fehler beim überladen des Constructor/ Obejkt ist Null");
                }
            }
            catch (Exception err)
            {
                //Ausgabe der Fehlermeldung in VS2017 und in der Ausgabe vom Zenon Editor
                System.Diagnostics.Debug.Print(err.Message);
                m_context.Workspace.Parent.DebugPrint("Fehler beim überladen des Constructor!", DebugPrintStyle.Error);
                // Applikation im Fehlerfall beenden.
                Environment.Exit(99);
            }


            string sProject = m_context.Workspace.ActiveProject.Name;
            
            m_Project = m_context.ProjectCollection[sProject];
            m_driver = m_Project.DriverCollection[Var[0]];
            //Fortschrittsbalken
            Stopwatch watch = new Stopwatch();
            watch.Start();


            //Treiber index finden
            //Aufbau Liste Var
            //0: Treiber
            //1: Netzadresse/Slavenummer
            //2: Name
            //3: DataTypBitSize
            //4: DataTyp
            //5: iGroup
            //6: Offset
            //7: DDE
            //8: Einheit
            //9: Nachkomma
            //10: SignalMin
            //11: SignalMax
            //12: WertMin
            //13: WertMax
            //14: Sollwert
            //15: SollwertMin
            //16: SollwertMax
            //17: Protokoll
            //18: ProtokollVBA
            try
            {




                //Variablen erstellen und parametrieren
                int z1 = 0;
                int z2 = 0;
                for (int i = 0; i <= Var.Count - 1; i = i + 19)
                {
                    //Variable einlesen
                    m_Var = m_Project.VariableCollection[Var[i + 2]];
                    //Prüfen ob Variable existiert
                    if (m_Var == null)
                    {
                        //Variable anlegen (Treiber, ChannleTyp???, und DataTyp)
                        
                        m_Project.VariableCollection.Create
                            (Var[i + 2], m_driver, ChannelType.PlcMarker, m_Project.DataTypeCollection[Var[i + 4]]);    
                        //Variable einlesen
                        m_Var = m_Project.VariableCollection[Var[i + 2]];
                        z1 = z1 + 1;
                    }
                    //context.Workspace.Parent.DebugPrint("Name: " + Var[i + 2], DebugPrintStyle.SystemMessage);
                    //context.Workspace.Parent.DebugPrint("DataTyp: " + Var[i + 4], DebugPrintStyle.SystemMessage);
                    
                    //Eigenschaften Variable setzen auch bei schon existierenden
                    //0 Treiber ist read only
                    
                    //1 Netzadresse
                    m_Var.NetAddress = Convert.ToInt16(Var[i + 1]);                           //int
                    //context.Workspace.Parent.DebugPrint("Netzadresse: " + Var[i + 1], DebugPrintStyle.SystemMessage);
                    
                    //2 Name ist bekannt
                    //Var[i+2]     //String
                    
                    //3 DataBitSize
                    m_Var.SetDynamicProperty("NGBitsize", Convert.ToInt16(Var[i + 3]));       //int
                    //context.Workspace.Parent.DebugPrint("Bitsize: " + Var[i + 3], DebugPrintStyle.SystemMessage); //4 Datatyp aktualisieren
                    
                    //4 DataTyp 
                    // wird beim erzeugen der Variable gesetzt                                 //IDataType


                    //Außnahme bei String Variablen
                    if (Var[i + 4] == "STRING") m_Var.StringLength = 80;                       //long


                    //5 iGroup
                    m_Var.SetDynamicProperty("NGIGroup", Convert.ToInt32(Var[i + 5]));          //int


                    //6 Offset
                    m_Var.Offset = Convert.ToInt32(Var[i + 6]);                                //int


                    //7 DDE
                    if (Var[i + 7] == "1") m_Var.SetDynamicProperty("DDEActive", true);        //bool
                    else m_Var.SetDynamicProperty("DDEActive", false);


                    //prüfen ob Eigenschaft vorhaden, wenn ja, dann setzen (Unit Digits SignalMin SignalMax RangeMin RangeMax SollwertMin SollwertMax Protokoll)
                    //8 Einheit
                    if (Var[i + 8] != "") m_Var.Unit = Var[i + 8];                                                  //String
                    //context.Workspace.Parent.DebugPrint("Einheit: " + Var[i + 8], DebugPrintStyle.SystemMessage);
                    
                    //9 Nachkommastelllen
                    if (Var[i + 9] != "") m_Var.Digits = Convert.ToInt16(Var[i + 9]);       //short  
                    //context.Workspace.Parent.DebugPrint("Nachkommastelllen: " + Var[i + 9], DebugPrintStyle.SystemMessage);
                    
                    //10 Signal Min
                    if (Var[i + 10] != "") m_Var.SignalMinimumRange = Convert.ToDouble(Var[i + 10]);                  // double
                    //context.Workspace.Parent.DebugPrint("Signal Min: " + Var[i + 10], DebugPrintStyle.SystemMessage);
                    
                    //11 Signal Max
                    if (Var[i + 11] != "") m_Var.SignalMaximumRange = Convert.ToDouble(Var[i + 11]);                  // double
                    //context.Workspace.Parent.DebugPrint("Signal Max: " + Var[i + 11], DebugPrintStyle.SystemMessage);
                    
                    //12 Wert Min
                    if (Var[i + 12] != "") m_Var.MeasuringMinimumRange = Convert.ToDouble(Var[i + 12]);               // double
                    //context.Workspace.Parent.DebugPrint("Wert Min: " + Var[i + 12], DebugPrintStyle.SystemMessage);
                    
                    //13 Wert Max
                    if (Var[i + 13] != "") m_Var.MeasuringMaximumRange = Convert.ToDouble(Var[i + 13]);               // double
                    //context.Workspace.Parent.DebugPrint("Wert Max: " + Var[i + 13], DebugPrintStyle.SystemMessage);
                    
                    //14 Sollwert setzen
                    if (Var[i + 14] == "1") m_Var.SetDynamicProperty("InOut", true);                                  //bool
                    else m_Var.SetDynamicProperty("InOut", false);
                    //context.Workspace.Parent.DebugPrint("Sollwert: " + Var[i + 14], DebugPrintStyle.SystemMessage);
                    
                    //15 Sollwert Min
                    if (Var[i + 15] != "" && Var[i + 14] == "1") m_Var.SetDynamicProperty("ValueMin", Convert.ToDouble(Var[i + 15]));     //double
                    //context.Workspace.Parent.DebugPrint("Sollwert Min: " + Var[i + 15], DebugPrintStyle.SystemMessage);
                    
                    //16 Sollwert MAx
                    if (Var[i + 16] != "" && Var[i + 14] == "1") m_Var.SetDynamicProperty("ValueMax", Convert.ToDouble(Var[i + 16]));     //double
                    //context.Workspace.Parent.DebugPrint("Sollwert Max: " + Var[i + 16], DebugPrintStyle.SystemMessage);


                    //17 Protokoll
                    if (Var[i + 17] != "") m_Var.SetDynamicProperty("IsSWProtokol", Convert.ToInt32(Var[i + 17]));  //int
                    //context.Workspace.Parent.DebugPrint("Protokoll: " + Var[i + 17], DebugPrintStyle.SystemMessage);
                    
                    //18 Protokoll VBA
                    if (Var[i + 18] == "1") m_Var.SetDynamicProperty("IsSW_VBA", true);       //bool
                    else m_Var.SetDynamicProperty("IsSW_VBA", false);
                    //context.Workspace.Parent.DebugPrint("Protokoll VBA: " + Var[i + 18], DebugPrintStyle.SystemMessage);
                    
                    //Grenzwerte und deren Farben bei Boolschen Variablen anlegen/setzen
                    if (Var[i + 4] == "BOOL")
                    {
                        //Wenn noch keine Grenzwerte vorhanden sind, werden bei Boolschen Variablen 2 Stück erstellt
                        if (Convert.ToString(m_Var.GetDynamicProperty("Limits[0]")) == "0")
                        {
                            m_Var.CreateDynamicProperty("Limits[0]");
                            m_Var.CreateDynamicProperty("Limits[1]");
                        }
                        //Standard ist Grenzwert 1 weiß Grenzwert 2 grün
                        //context.Workspace.Parent.DebugPrint("BOOL", DebugPrintStyle.SystemMessage);
                        m_Var.SetDynamicProperty("Limits[0].Color", 16777215);
                        m_Var.SetDynamicProperty("Limits[1].Color", 65280);
                    }
                    if (m_Var.Name.Contains("OutputsWindow"))
                    {
                        //Ausnahme Fensterkontakte 1 ist blau und 2 ist rot
                        //context.Workspace.Parent.DebugPrint("BOOL und Fenter", DebugPrintStyle.SystemMessage);
                        m_Var.SetDynamicProperty("Limits[0].Color", 16711680);
                        m_Var.SetDynamicProperty("Limits[1].Color", 255);
                        m_Var.SetDynamicProperty("Limits[1].Blinking", true);
                    }


                    z2 = z2 + 1;
                }


                watch.Stop();
                context.Workspace.Parent.DebugPrint(Convert.ToString(z1) + " Variablen wurden neu angelegt.", DebugPrintStyle.SystemMessage);
                context.Workspace.Parent.DebugPrint(Convert.ToString(z2 - z1) + " Variablen wurden aktualisiert.", DebugPrintStyle.SystemMessage);
                context.Workspace.Parent.DebugPrint("Benötigte Zeit: " + watch.Elapsed, DebugPrintStyle.SystemMessage);
            }
            catch (Exception err)
            {
                context.Workspace.Parent.DebugPrint(err.Message, DebugPrintStyle.SystemMessage);
            }


        }

Bei deiner Lösung würde ich aus dieser Liste jetzt einfach eine XML Datei erstellen, das sollte ein überschaubarer Aufwand sein.
Hast zu zufällig ein Beispiel für einen Import einer XML Datei per AddIn. Schwer wird das ja nicht sein, über Abkürzungen freu ich mich trotzdem immer.

Gruß Tobias

[FredrikV]

Hi!

If you check the following page in the object model:
ObjectModel->Add-InVariable->IVariableCollection->IVariableCollection Methods->ImportXmlDirect

It contains an example.

bool ImportXmlDirect(    
                     string fileNameOrFilePath,    
                     bool overwriteIecDataTypes,    
                     bool overwriteUserDefinedDataTypes
                     )

[zero]

Super vielen Dank