Danke vielmals für die Hilfestellungen!
Was ich als Kernbotschaft mitnehme ist folgendes:

Die ".xaml.cs" muss im Idealfall gar nicht angefasst werden.

Ich bin zu Erkenntnis gekommen, dass wohl Delphi und Co meinen Verstand verdorben haben!
Ich habe schon versucht, mir die Tutorials und Co lesend anzueignen. Ich bin nicht in der Lage, den Inhalt behind zu erfassen, denn ich habe keine Informatikerausbildung! Ich habe mir alles, was ich über Programmierung weiss mir selber beigebracht. So habe ich es auch hier versucht! Eigentlich sollten die Computerprogramme dem Menschen helfen und das Wissen für ihn verdaubar sein. Ich hhabe hier den Eindruck, dass die Computerprogramme den Menschen entfremdend verändern. Ich bin frustriert und werde mich zurückziehen und mir mein Wissen weiterhin alleine ohne erneute Hilfe erarbeiten! Ich weiss, dass ich es schaffen werde, habe ich bisher auch immer geschafft.
Daher werde ich mich nun vom Forum verabschieden.

#Administrator: Mein Account kann gelöscht werden
EccoBravo

Hallo, hier bin ich wieder!
Oh welch ein Wunder, ich habe gestern abend vom benannten Amerikaner ein Musterprojekt bekommen, welches mit meiner Softwareumgebung UND dem WPF umgehen kann.
Ich habe es mir dieses vorgenommen und an meine einfachen Wünsche angepasst.
Ich starte jetzt das C# Projekt (dll) aus meiner Softwareumgebung heraus und bekomme tatsächlich ein Window mit einem Label UIcontrol mit dem Namen des geladenen Datensatzes angezeigt. Darüber bin ich erst mal sehr glücklich. Vwerstanden habe ich damit aber immer noch nichts!
Nun lasse ich in meinem Projekt eine for next Schleife laufen und möchte mir im vorhandenen Label UIcontrol den durchlaufenden Index anzeigen lassen. Diesen Gefallen tut mir mein Programm aber nicht. Nach der Anzeige des Datensatznamens ist die Arbeit des window beendet und der Label UIcontrol bleibt auf den Datensatznamen stehen.

. . . 
// Progressbar aufrufen         
var mainControl = new Test_WPF.MainControl();
window.Content = mainControl;
window.Width = 610;
window.Height = 460;
window.Title = "Test_WPF";

mainControl.L_Vali.Content = Datensatz.Name;   // auszulesender Datensatzname  wird angezeigt
window.ShowDialog();
         
for (int zi = 0; zi < 100; zi++)
{
        mainControl.L_Vali.Content = (zi + 1).ToString();  // soll angezeigt werden, wird aber nicht
        //mainControl.UpdateLayout(); ??
}                    
. . . 

Der xaml Code:

UserControl x:Class="Test_WPF.MainControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             Height="171.403" Width="575">
    <Canvas>
        <Border Margin="40" BorderThickness="1" BorderBrush="Black">
            <Canvas x:Uid="MainCanvas" x:Name="MainCanvas" Width="500" Height="88">
            </Canvas>
        </Border>
        <Label x:Name="L_Vali" Canvas.Left="181" Canvas.Top="12" Content="" FontWeight="Bold" />
    </Canvas>
</UserControl>

Und der .xaml.cs Code:

namespace Test_WPF
{
    /// <summary>
    /// Interaction logic for MainControl.xaml
    /// </summary>
    public partial class MainControl : UserControl
    {
        public MainControl()
        {
            InitializeComponent();
        }
        public void pb(int vali, int maxi, int mini)  // pb macht eigentlich keinen Sinn, glaube, brauche ich nicht. 
        {
            L_Vali.Content = vali.ToString();
        }
    }
}

Ein einfaches Zuweisen des Indexes auf die Content Eigenschaft des Label UIcontrols funktioniert nicht, ein Window refresh gibt es nicht...

Nicht dass Ihr mich falsch versteht, Ihr sollt wirklich nicht mein Projekt zuende programmieren! Ich will nur wissen, wie ich zur Laufzeit einen Label UIcontrol aktualisiere!

Nicht dass Ihr wieder anfangt, mit Wattebällchen zu werfen! Im Internet habe ich einiges zu DataBinding, asynchroner Programmierung und Multithreads gefunden und wollte das probieren. Dabei bin ich vollkommen durcheinander gekommen, da diese Experten nicht schreiben, was in die .xaml.cs und was in die .cs Datei kommt. Ich bekomme immer mehr den EIndruck, dass die Erzeuger der UIcontrols nur halbe Arbeit gemacht haben. Ich muss mich um den ganzen Thread-Kram kümmern, der gehört doch von vorne herein in die UIcontrols hinein, das muss ich doch nicht erst selbst basteln!!! Wir leben in 2021, aber bei C# bekomme ich immer mehr den Eindruck in die (0er Jahre des letzten Jahrtausend zurückgebombt worden zu sein!

Ich habe mir auch das Visual C# 2019 Rezeptebuch von Jürgen Kotz besorgt und umhergelesen. Darin schwafelt er von DataBinding, asynchroner Programmierung und Multithreads. Mir wird auch hier nicht klar, was davon in die .cs und was in die .xaml.cs gehört.

35 Jahre Programmiererfahrungen, an die 100 super laufende Projekte aber an C# breche ich mir das Genick!" Fliegt zum Mond aber verunglückt beim Fahrradfahren!"
Nun bitte keine roten Wattebällchen!
Vielen Dank EccoBravo

Danke für die Antworten!
Ich werde versuchen, was ich kann.
Nach dem Abendbrot werde ich mir alles nochmal zu Gemüte ziehen.
Wichtig, dass am Ende eine sinnvolle Technologie steht!
Bis dahin
VD EccoBravo

Jetzt macht die Konversation endlich Spass!
Ich verweigere ja nicht neuen Wissenserwerb. Ich glaube ja auch nicht, dass Ihr von einem 60jährigen das Geburtsdatum ändern wollt!
Wenn ich nicht wollen würde, würde ich doch nicht weiter fragen.
Ich stelle mir erst mal ein paar Aufgaben, doch mit einem Create WPF anzufangen und die dll dann als Referenz hinzuzufügen.
Es werden dann bestimmt eine Menge Folgeprobleme entstehen. Das wichtigste dabei, dass mein auftraggebendes System diese Projekt dann auch noch als Script erkennt.
Aber wenn man auf einem Weg nicht weiterkommt, muss man eben einen anderen gehen. Ich hoffe, dass dieser Plan nicht im Kampf der Giganten endet!
Zu meiner Environment, es gibt eine sehr kleine amerikanische Community, von denen vielleicht zwei-drei Menschen dieses beherrschen, diese bekommt man aber kaum zum Kontakt, daher meine endlosen Eigenversuche.
Alternativ werde ich nochmal weiter versuchen, die benötigten Bibliotheken zu finden.
Ich dachte bisher nur, dass es noch Alternativwege gäbe.

Ungeachtet meines zu bekämpfenden Frustes, C# ist viel obskurer, als mein alt geliebtes Delphi. Dafür sind die Codes erheblich kürzer!

Den Schritt von PL1 zu Delphi hat man mir in 30 Minuten erklärt. Fortran habe ich ohne Probleme parallel programmiert. Ich hätte nicht gedacht, dass man nun alles neu erlernen muss. Keiner hat mir den grundlegenden Unterschied erklärt.

VD
EccoBravo

Vielen Dank für diese verständnisvolle Antwort!
Ich bin eben kein Informatiker, mir fehlt ziemlich viel Hintergrundwissen, weswegen sich mich viele Beschreibungen/Tutorials nicht erschliessen. Ich habe es vorher schon versucht, in diese Welt tiefer einzutauchen, aber viele Sachen funktionieren dann in praxi bei mir nicht, und daher bin ich immer auf der Suche nach möglichst einfachen Wegen. Oftmals hat es dann auch geklappt.
Wenn ich dann eine Lösung gefunden habe, versuche ich diese auch für andere Projekte zu verwenden. Deshalb bin ich doch kein "schlechter" Mensch!
Wenn mich jemand etwas fragt, versuche ich mich doch in diesen hineinzudenken und ihn dort abzuholen, wo er gerade steht! Sonst bräuchte er gar nicht zu fragen, sonst bräuchte man auch nicht dieses Forum!

"Hast Du eine Projekt-Datei, oder nur die cs-Datei?
Oder kannst Du eigene DLLs als Referenzen hinzufügen?"
Ja, beides habe ich.

Das ist klar, ich will ganz WPF erlernen, nur fehlte mir der Zugang, und wie bekomme ich es "an meine cs-Datei angekoppelt"!
Dann können wir auch Rechencode und UI sauber von einander trennen.
Dazu müssen kein paar Knoten aus meinem Gehirn und deshalb frage ich doch!
Wenn man mir den Tipp gibt, wie ich die XAML und XAML.cs Dateien an meine cs Datei in einer sln oder cproj zusammenbekomme wäre ich glücklich!
Bei Delphi ging das alles.

Was ist denn bei C# und VS anders als bei Delphi?

Vielen Dank!
EccoBravo

Zwei Löwen - zwei Salathaufen !
Er hat mir nicht gesagt, wo die Bibliotheken sind !

Genau das geht nicht, weil dann die proprietären Bibliotheken fehlen, von denen ich nicht weiss wo diese sind.
Und weil ich das nicht weiss, versuche ich es eben andersrum!
Und weil mir die WPF Art zu unzugänglich ist, versuchte ich es mit einem einfachen Window window.

In der Vergangenheit habe ich sogar ein Projekt gemacht, wo ich eine Grafik als Window über einen HTML String mit Java Einfügung programmiert habe, nur um das für mich obscure WPF zu umgehen
VD
EccoBravo

Von einem Insider (Amerikaner) habe ich den Hinweis bekommen, ein WPF Project zu erstellen und den vorherigen Skript dort hineinzukopieren.
Dieses erwies sich als Holzweg, weil er die benötigten Bibliotheken verliert, die sich scheinbar nicht als Code editieren lassen. Keiner konnte mir erklären, wo ich diese Bibliotheken finde. Es ist alles proprietär.
VD
EccoBravo

So geht es eben einen Löwen, dem man einen Haufen Salatblätter hinwirft und ihm zuruft: "Friss doch endlich Du Dummkopf!"
Ich habe einfach nur eine .cs Datei mit allen, von meiner Software Umgebung benötigten Bibliotheken.
Daraus will ich ein Project/Solution erzeugen, damit ich weiter komme. Dann muss man mir nur noch verraten, wie ich die WPF-Biliotheken / <XAML anbinde!
Nichts weiter! Dann werde ich auch die VS / C# Philosophie verstehen.
Ich hoffe auf die gleiche Geduld, wie ich sie beim Fragen habe!

VD
EccoBravo

Neben WPF gibt es da noch XAML. Damit habe ich auch schon herumprobiert. Keiner hat mir das so richtig erklärt.
Es scheitert an den einfachsten Sachen. Wie bekomme ich den ganten XAML Gedöns an mein Skript. Wie wandle ich ein cs Skript in ein Project/eine Solution, damit ich Referencies etc einbinden kann...? ETC, etc....

Vielen Dank für die von oben beleuchtete Antwort!
Ich bin KEIN Informatiker und habe mir die Sache selbst angenommen!!!
Ich denke schon, dass ich in der Vergangenheit schon mit einigem Grundverständnis an die Sachen gegangen bin.
Zu meinem Arbeits-Kontext:
Ich arbeite für eine große Software-Umgebung, die C# als Skriptsprache benutzt.
Um mit den Skripten arbeiten zu können, muss man ein SkriptProjekt mit dem zugehörigen Wizard eröffnen, damit alle Bibliotheken und Linkprocedures vorhanden sind!
Wenn Windows Dialoge dazu haben will, müsste ich WPFs haben. Dazu muss ich aber das Projekt mit Create WPF-Project eröffnen, dann habe ich aber nicht die o.g. Bibliotheken.
Das habe ich alles schon mal versucht, so zusätzlich ein WPF-Project kreiert und dann den gesamten o.g. Program Knödel hineinkopiert. Hat alles nicht funktioniert!
Entweder WPF oder mein o.g. Program Knödel!
Nach 2 Wochen Herumforschen, Internetrecherchen und Literaturstudium, Herstellerunterlagen etc. habe ich mich mal an das Forum gewendet.
So viel dazu !
Vielen Dank für die Unkompetenzbescheinigung!

VG
EccoBravo

Vielen Danke für die Antwort,
ich programmiere schon viele Jahre, aber mit Visual Studio komme ich einfach nicht klar!
Selbst das Umbenennen eines Projektes in VS ist ein Abenteuer!
Daher meine beiden Fragen im Forum.
Ich habe schon einiges probiert, vermisse aber ein refresh im window.

VD + HG
EB

Hallo,
gleich die nächste Anfängerfrage:

Wie kann ich in VS einen einfachen Skript um die WPF Funktionalität erweitern?

Voraussetzung:
Ich habe einen mit einen SkriptWizard erzeugten Skript fertig programmiert (Mit dem Wizard werden alle Bibliotheken des Hosting Environment mitgegeben).
Zur AnwenderErweiterung des Skriptes möchte ich einen Window Dialog in den fertigen Skript einbinden.
Dazu habe ich aber keinen Plan.

Bitte:
Kann man mir da einen einfachen, übersichtlichen Fahrplan geben?
Ich bin in C# Skripting ein Anfänger.

VD + HG
EccoBravo

Hallo ,

ich bin neu hier und komme mit einer einfachen Anfängerfrage.
Ich möchte einen Script ohne WPF schreiben.

Dieser Script hat eine lange Abarbeitungszeit
und ich möchte den Zwischenstand / Verlauf auf einfache Weise anzeigen,
um dem Nutzer zu zeigen das sich da was tut und wann der Skript fertig wird.
Messagebox scheint dafür auszufallen, da ich bei Zwischenstand jedesmal OK drücken muss.
WPF Programmierung ist mit zu aufwändig und ich versuche mich auf eine einfache **Window window __**Variante zu beschränken.

Dazu mal meinen vereinfachten Code:

///////////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////////
using System;
using System.IO;
using System.Linq;
using System.Text;
using System.Windows;
using System.Collections.Generic;
using System.Windows.Controls;
using System.Reflection;
using Excel = Microsoft.Office.Interop.Excel;
using System.Linq.Expressions;
using System.Threading;

// TODO: Replace the following version attributes by creating AssemblyInfo.cs. You can do this in the properties of the Visual Studio project.
[assembly: AssemblyVersion("1.0.0.3")]
[assembly: AssemblyFileVersion("1.0.0.3")]
[assembly: AssemblyInformationalVersion("1.03")]

namespace VMS.TPS
{
    public class Script
    {
        public Script()
        {
        }
        double BlaBla;
        class abListD
        {
            internal double BlaBlaBla;
        }
        class abListS
        {
            internal string BlaBlaBla;
        }
        
        //---------------------------------------------------------------------------------------------  
        public void Execute(ScriptContext context, Window window)
        {
            . . . BlaBlaBlaBla;
            . . .                                   
            //.....................................................................................
            // Ergebnis-Fenster Eigenschaften
            window.Background = System.Windows.Media.Brushes.Yellow;
            window.Background = System.Windows.Media.Brushes.LightGreen;
            window.Foreground = System.Windows.Media.Brushes.DarkBlue;

            window.Height = 465;
            window.Width = 350;
            window.Title = "BlaForm";

            InitializeUI(window);

            //.....................................................................................
            . . .   // Code
  

            Label_1.Content = bla1;
            label_2.Content = bla2;
            label_3.Content = bla3;
          
            label_Daten.Content = „Daten“;

            window.Show();

            // whole 3D matrix will be scanned
            for (int zi = 0; zi < dimZi; zi++)
            {
                . . . // langer Code
                Label_Daten.Content = "Daten   " + zi.ToString() + " / " +  dimZi.ToString();
                    
                for (int yi = 0; yi < dimYi; yi++)
                {
                    . . . // langer Code
                    for (int xi = 0; xi < dimXi; xi++)
                    {
                        . . . // langer Code
                    }  // xi
                }      // yi
            }          // zi
        }              // Execute
        
        // ######################################################
        // Ergebnis Fenster

        void InitializeUI(Window window)
        {
            StackPanel rootPanel = new StackPanel();
            rootPanel.Orientation = Orientation.Vertical;   //Frames untereinander im Root-Window
            {
                //.....................................................
                // bla
                GroupBox groupBLA = new GroupBox();
                groupBLA.Header = "Bla";
                rootPanel.Children.Add(groupBLA);

                StackPanel panelBLA = new StackPanel();
                groupBLA.Content = panelBLA;
                groupBLA.Foreground = System.Windows.Media.Brushes.Blue;

                panelBLA.Orientation = Orientation.Vertical;   //Horizontal;
                panelBLA.Children.Add(label_1);
                panelBLA.Children.Add(label_2);
                panelBLA.Children.Add(label_3);

                //.....................................................
                //Daten-Ergebnisfelder im Frame
                GroupBox groupDATEN = new GroupBox();
                groupDATEN.Header = "Schichten";
                rootPanel.Children.Add(groupDATEN);

                StackPanel panelDVH = new StackPanel();
                groupDATEN.Content = panelDATEN;
                groupDVH.Foreground = System.Windows.Media.Brushes.Blue;

                panelDATEN.Orientation = Orientation.Vertical;
                panelDATEN.Children.Add(label_Daten);
            }
            window.Content = rootPanel;
            window.Title = "Bla";
        }

        //Ausgabe-Felder für Text und Ergebnisse
        Label label_Daten = new Label();
       
        Label label_1 = new Label();
        Label label_2 = new Label();
        Label label_3 = new Label();
    }
}

Mit **window.Show(); __**erzeuge ich ein einfaches, in void InitializeUI(Window window)
__ festgelegtes Fenster.

Im Programmablauf sollte mir das Fenster zeigen wo (zi) ich mich von dimZi (von wie vielen) befinde.
**
Mein Problem ist, **
Mit dem o.g. Programmcode zeigt er mir nicht das veränderliche **zi von dimZi __**an.

D. h. nach Änderung von Label_Daten.Content = "Daten " + zi.ToString() + " / " + dimZi.ToString();__
wird mir nicht die Änderung im **Window window __**angezeigt.

Kann mir da jemand helfen?
VD + HG
EccoBravo