Nun versuche ich gerade alles hinterm @ und einem Space oder dem Ende des Strings auszulesen, um die Namensliste anzupassen.

Dazu brauchst du kein RegEx, das kannst du alles mit den Methoden der String-Klasse erledigen: IndexOf, Substring, TrimEnd.

Wahrscheinlich werden die SVGs dynamisch gerendert. Dann sind die nicht im Seitenquelltext zu finden.

Du könntest die Anwendung automatisiert über den Task Scheduler starten lassen, und die zu erstellenden Reports über Kommandozeilenparameter übergeben.

Nur weil eine neue Technologie deine Herangehensweise unterstützt, heißt das nicht, daß man es auch so machen sollte. Eine Eigenschaft, die dem Benutzer angezeigt werden soll und nicht in der DB gespeichert wird, gehört nicht ins Datenmodell sondern ins ViewModel, ebenso ObservableCollections. Siehe dazu:

[Artikel] Drei-Schichten-Architektur
[Artikel] MVVM und DataBinding

Und wenn man mit EF einen Datensatz ändern will, dann liest man zuerst den aktuellen Datensatz aus, mappt die geänderten Eigenschaften (z.B. mit AutoMapper) und schreibt dann diesen geänderten Datensatz wieder zurück. So kann EF die Änderungen tracken und automatisch aktualisieren.

Hier gibt es eine ausführliche Anleitung: [Tutorial] Zeichnen in Windows-Forms-Programmen (Paint/OnPaint, PictureBox)

Du solltest auch darauf achten, Resourcen wie Pens und Bitmaps wieder freizugegeben. Sonst bekommst du irgendwann eine OutOfMemoryException.

kommen System.NullReferenceException in praktisch allen Klassen

Kannst du das genauer erklären?

Such mal nach: Webservice, Web API, REST.

Wenn es sich um eine lokale Datenbank handelt, benötigt man keinen Webservice. Was man aber braucht, ist eine Trennung in Datenzugriffsschicht (DAL) und Benutzeroberfläche (UI). In der DAL wird die Zuordnung abgefragt und geändert, und in der UI wird diese Zuordnung über ein Command ausgelöst, und das Resultat angezeigt.

Die Fragen nach Filter, Labda-Expressions und SQL-Anweisungen verstehe ich nicht. Wir wissen weder, wie deine Datenbank aufgebaut ist, noch kennen wir deine deine Modelle. Wo genau liegt dein Problem?

Gibt es eine Fehlermeldung im Ausgabefenster?

Ein Beispiel dafür gibt es in [Artikel] MVVM und DataBinding im Abschnitt "Commands".

Das Debuggen von Bindings ist dort auch im Abschnitt "Debugging" beschrieben.

3D-Fragen können ruhig auch hier im Forum gestellt werden, ein paar Community-Mitglieder haben schon Erfahrung damit. Man sollte allerdings nicht gleich eine spezielle Umsetzung in einer wenig verbreiteten 3D-Engine erwarten. Aber die prinzipiellen Vorgehensweisen und die verwendeten Technologien sind überall im 3D-Bereich zumindest ähnlich.

Allerdings muß man halt auch eine Frage stellen, sonst wird man keine Antwort bekommen 😉
Siehe die Tips in [Hinweis] Wie poste ich richtig?

Die einzige Problembeschreibung, die sich aus dem Beitrag ergibt, ist das:

Hilfe könnte ich bei den Texturen (Spiegelungen um genau zu sein) brauchen, das ist etwas schwerer zu verstehen.

Dazu solltest du einen eigenen Beitrag aufmachen, und das Problem genauer erklären. Mit Spiegelung kann hier die Spiegelung einer Textur oder die Spiegelung der Umgebung gemeint sein. Beim ersterem müßtest du die Texturkoordinaten invertieren, und bei zweiterem gibt es sicherlich dafür schon ein Flat Mirror-Material oder Environment Maps in der 3D-Engine.

Ich kann deiner Erklärung nicht folgen, ich bin schon an dieser Stelle ausgestiegen:

In den Resources.xaml sind dann alle Styles definiert, ich habe bei den beiden oben genannten jedem Style einen eindeutigen x:Key gegeben, damit sich diese laut meinem Kollegen nicht gegenseitig aufgeben.

Keine Ahnung, was dir deine Kollegen gesagt haben, aber was der x:Key macht, sollte eigentlich klar sein. Mit Key kannst du den Style auf ein Element anwenden, indem du dort den Key des Styles angibst. Ohne Key wird der Style auf alle Element angewendet, die dem TargetType entsprechen. In deinem Codeausschnitt gibst du entgegen deiner Aussage aber keinen Key an.

Ansonsten ist dein Problem ziemlich komplex. Wenn ich es richtig verstehe, willst du das DataGrid von WPF durch ein eigenes ersetzen. Dann solltest du dir die Styles und Templates des DataGrids anschauen, und Stück für Stück durch dein eigenes ersetzen. Ich kann mir nicht vorstellen, daß das schonmal jemand gemacht hat (wüßte auch nicht, wozu).

Die Alternative wäre, nur eigene Elemente **in **den Headern verwenden (statt eigene Header usw.).

Man muß RaiseCanExecuteChanged aufrufen, sobald sich der Wert (bzw. einer der Werte), die im CanExecute abgefragt werden, ändern (d.h. man muss daraus Eigenschaften machen und im Setter dann command.RaiseCanExecuteChanged() aufrufen)

Nein, muß man nicht, so ist das nicht gedacht. Stattdessen sollte man den CommandParameter mittels DataBinding festlegen. Dann wird der Status neu überprüft, sobald sich der gebundene Wert ändert. Falls der Status von mehreren Werten abhängig ist, kann man auch (Multi)Trigger verwenden. In allen anderen Fällen kann man den Button auch unabhängig vom Command aktivieren oder deaktivieren.

Noch immer hänge ich an dem Punkt, nachdem das Command dem ViewModel übergeben wurde und das ViewModel einen entsprechenden Constructor besitzt, wie der Code weiterzuführen ist auf ViewModel-Seite.

Du hast ein Command und einen Button, der das Command auslösen soll. Dann mußt du nur das Command an den Button binden:

<Button Command="{Binding MyCommand}" />

Ich empfehle, dir mal diesen Artikel durchzulesen, besonders den Abschnitt zu Commands: [Artikel] MVVM und DataBinding

Eigentlich braucht dein Service nur eine Methode um eine Navigation auszulösen, und ein Event, um über die Navigation zu benachrichtigen.

Da bin ich aktuelle gänzlich überfordert und wüsste nicht mal, wie ich starten sollte. 👶

Du mußt ein Event erstellen, dieses Event auslösen, und dann auf das Event reagieren. Das wird alles in dem oben verlinkten Artikel zu Events erklärt.

Wenn das im Moment noch zu kompliziert ist, solltest du dich nochmal mit den Basics beschäftigen, bevor du WPF-Programme entwickelst. Das sind die Grundlagen, die überall benötigt werden. Siehe auch: [FAQ] Wie finde ich den Einstieg in C#?

Grundsätzlich macht der Ansatz einen Navigationservice zu nutzen auch für meinen laienhaften Kenntnisstand sind. Allerdings denke ich auch, da ich grundsätzlich in meinem Programm nur einen ChildView habe, ist es vielleicht etwas wie mit Kanonen auf Spatzen.

Deswegen hatte ich ja noch zwei andere Herangehensweisen vorgeschlagen.

Das Beispiel für den NavigationService ist so konstruiert, um jedes mal neue Windows zu öffnen. Kann ich das problemlos adaptieren auf meine ContentControls der einzelnen Views?

Eigentlich braucht dein Service nur eine Methode um eine Navigation auszulösen, und ein Event, um über die Navigation zu benachrichtigen.

Das Problem besteht anscheinend darin dass ich irgendetwas vergessen habe oder einfach falsch verstehe.

Weder erstellst du das Objekt so, wie es im verlinkten Artikel erklärt ist, noch definierst du ein Event. Entweder solltest du den Artikel nochmal genauer lesen, oder eine alternative Herangehensweise suchen (siehe Abts Antwort).

Leider zeigtst du nicht, wo du das Event definiert hast, und wo ChildVM initialisiert wird. Offenbar hast du doch ein paar mehr Schichten, als im Eingangsbeitrag, wo es noch halbwegs übersichtlich klingt.

Es gibt mehrere Möglichkeiten:

• Das Event durch die verschiedenen Schichten (VM4 => ChildVM => MainVM?) durchreichen

• Ein Command in die andere Richtung durchreichen (MainVM => ChildVM => VM4):

public class MainVM : BindableBase
{
  private ICommand navigateToHomePageCommand = new BaseCommand(NavigateToHomepage);
  private ICommand navigateToChildViewCommand = new BaseCommand(NavigateToChildView);

  public void NavigateToHomepage(object parameter)
  {
     NavigateTo = new HomePageVM();
  }

  public void NavigateToChildView(object parameter)
  {
     NavigateTo = new VMXXX(navigateToHomePageCommand);
  }
}

So kann der Button direkt auf das navigateToHomePageCommand gebunden werden.

• Die Navigation in einen NavigationService auslagern und diesen (z.B. per Dependency Injection) an alle ViewModels übergeben. Dann kannst du diesen Service von überall verwenden, um zu einer Seite zu navigieren, und das MainViewModel kann auf die Änderungen reagieren.

Ich komme ehrlich gesagt nicht klar mit dem Konstrukt aus Event und ViewModel.

Erkläre doch bitte mal, wo genau dein Problem liegt. Es geht doch hier lediglich darum, ein Event zu erstellen, auszulösen und zu abonnieren. Das ist alles in der Doku und in dem verlinkten Artikel beschrieben. Wenn du trotzdem etwas nicht verstehst, dann mußt du das halt mal erklären.

Daß bisher noch keine Antwort eingegangen ist, liegt wohl an deiner Frage. Niemand wird dir aus dem Kopf den Unterschied zwischen den beiden genannten Funktionen nennen können. Und eine fertige Lösung für dein spezielles Problem, nach der du ausdrücklich fragst, wird auch kaum jemand hier posten können.

Siehe dazu auch [Hinweis] Wie poste ich richtig?:
4. Verlangt keine fertigen Lösungen
4.2. Wälzt nicht eure Aufgaben auf uns ab

Aber es scheint klar zu sein, daß dein Konzept so nicht funktionieren kann. Wenn du einen Tastendruck global abfängst und behandelst, kannst du nicht davon ausgehen, daß es nach einer von dir festgelegten Zeit magischerweise nocheinmal gesendet wird. Das mußt du natürlich selbst an der richtigen Stelle nochmal senden.

[FAQ] Eigenen Event definieren / Information zu Events (Ereignis/Ereignisse)

Wow. So viel Arbeit, um die Dateireihenfolge von einem 30 Jahre altem Programm zu ändern, für das du nichtmal den Quellcode hast. In der Zeit hättest du ein eigenes Scan-Tool schreiben können.

Da wird dir wohl niemand weiterhelfen können.

Deinem Vater würde ich ein moderneres Tool zum Scannen empfehlen, bei dem man die Dateinamen selbst festlegen kann.

Wenn die Infos nicht in der Datei stehen, kannst du sie auch nicht auslesen oder ändern.

Wenn beim nächsten Öffnen der Datei die Werte wieder angezeigt werden, sind sie aber wohl doch darin gespeichert.

Kannst du mal erklären, was du _eigentlich _vor hast? Um was für Dateien handelt es sich hier? Was willst du damit erreichen? Deine anderen Beiträge ([gelöst] SendMessage an ListView in anderem Prozess und Message Hook für andere Anwendungen) deuten irgendwie auf eine sehr unüberlegte Herangehensweise hin.

ViewModel4 könnte ein Event besitzen, das beim Klick auf den Button ausgelöst wird. Das MainViewModell reagiert dann auf das Event, indem es wieder zur ersten View navigiert.

Du meinst sicher "UserControl". Ein UserControl dient nur der Ausgabe und Eingabe eines Wertes. Die Logik gehört nicht in das UserControl, sondern ins ViewModel. Dort lassen sich dann Methoden ausführen, ohne auf die View zugreifen zu müssen.

Das wird sicherlich ein Eintrag in den EXIF-Daten des Bildes sein. Du kannst dir die Einträge anschauen, indem du mit der rechten Maustaste auf die Datei klickst, und dann unter "Eigenschaften" die "Details"-Seite aufrufst. Zum Auslesen mit C# gibt es fertige Bibliotheken.

Falls du mit Windows Forms entwickelst: [Tutorial] Zeichnen in Windows-Forms-Programmen (Paint/OnPaint, PictureBox)
So kannst du auch Bitmaps erstellen und darauf andere Bilder platzieren und skalieren.

Falls du eine Web- oder andere Anwendung hast, mußt du deine Frage mal aktualisieren.

T-Virus hat Recht, wenn die Größe vorher nicht bekannt ist (das hatte ich übersehen), dann verwendet man eine List<T>. Wenn man dann am Ende ein Array benötigt, dann kann man das aus der Liste mit der ToArray()-Methode erstellen.

Eigentlich müssten es ja k x i -viele Einträge im Array dann sein, das ich zurückgeben will.

Wenn die Anzahl bekannt ist, kannst du ja vorher (außerhalb der Schleife) das Array in der richtigen Größe initialisieren.

Versuch mal:

return Items;

Du solltest dir den Artikel auch mal durchesen. Dort werden eigentlich die meisten deiner Fragen beantwortet. Eine ObservableCollection ist eine Implementierung einer Liste für das DataBinding mit MVVM in WPF, und gehört daher zur View. Wenn du diese jetzt in der Datenzugriffsschicht verwenden willst, hast du das Konzept ganz grundlegend nicht verstanden.

Mit DataTables habe ich noch nie gearbeitet, daher kann ich dazu nichts sagen. Normalerweise würde man dazu Klassen erstellen und verwenden, die die Daten repräsentieren (POCOs).

Ob man die Schichten sauber getrennt hat, merkt man spätestens beim Testen. Wenn du die Funktionalität aus einzelnen Schichten unabhängig von Funktionalität aus den anderen Schichten testen kannst, ist deine Architektur sauber, und sonst halt nicht. Wenn du eine Collection aus WPF benötigst, um deine DAL zu testen, dann eben nicht. Aber wenn du noch nie deinen Code mit Unit-Tests getestet hast, ist das alles nur Theorie.

Und was hat Ockham's Razor damit zu tun? Ockham war ein mittelalterlicher Mönch, der sich mit (wissenschaftlichen) Erklärungsansätzen für unerklärliche Phänomäne beschäftigt hat, nicht mit Entwurfsmustern aus der Software-Entwicklung.

Liest du dir die Antworten auf deine Frage eigentlich auch durch?
Niemand würde das so machen, SharePoint hat eine API, die genau für diese Zwecke entwickelt wurde. Wenn du die nicht verwendest, wird dir wohl niemand weiterhelfen können.

Das ist kein Code und es gibt auch keine Event-Handler in CSS, daher ist es schwierig, deine Gendanken nachzuvollziehen.

Es sind Styles, und du kannst sie mit einer Kombination von Selektoren auf jedes beliebige Element anwenden:

#page1:target, 
#page2:target {
    /* Style for selected pages */
}

#page1:target #overview, 
#page2:target #overview {
    /* Style for overview inside selected pages */
}

#page1:not(:target) #overview, 
#page2:not(:target) #overview {
    /* Style for overview inside unselected pages */
}

/* usw. */

Hier gibt es eine Übersicht der Selektoren: CSS Selector Reference

Schöner geht es nur noch mit SCSS, das müßtest du aber vorher zu CSS kompilieren:

#page1, 
#page2 {
  /* Style for unselected pages */

  #overview {
    /* Style for overview inside unselected pages */
  }

  &:target {
      /* Style for selected pages */
  
    #overview {
        /* Style for overview inside selected pages */  
    }
  }
}

Du wirst aber niemals erreichen können, daß ein Element innerhalb eines unsichtbaren Elternelements wieder sichtbar wird. In dem Fall mußt du das Element außerhalb des Elternelements definieren.

Dann verstehe ich nicht, was du erreichen möchtest. So, wie du es geschrieben hast, ist es jedenfalls kein gültiges CSS, daher kann es nicht funktionieren.

Nein, ein Buch kenne ich nicht, und auch keinen Kurs. Es ist eigentlich aber gar nicht so kompliziert.

Zu deinen Fragen würde ich empfehlen, jeweils einen eigenen Beitrag aufzumachen, und dort den relevanten Code mit der Frage zu posten.

#overview.display: none; funktioniert nicht.

Probier mal:

#overview {
  display: none;
}

So würde es ausreichend, denn die Auflistungen werden ja nicht neu erstellt, sondern nur deren Einträge:

    public class MainViewModel : ViewModelBase
    {
        
        public ObservableCollection<ItemViewModel> Items{ get; } = new ObservableCollection<ItemViewModel>();

        public ObservableCollection<StatusViewModel> Status { get; } = new ObservableCollection<StatusViewModel>();

    }

Beachte die Benennung, da die Basisklasse und die Einträge der Listen ViewModels sind.

Ich kann noch nicht nachvollziehen, an welcher Stelle es jetzt klappt, und an welcher Stelle nicht. Du sagst, daß nachträglich hinzugefügte Elemente nicht mehr in der Liste angezeigt werden? Werden die auch über die AddItem-Methode hinzugefügt?

Die CollectionChanged-Methode ist allerdings überflüssig, die ObservableCollection-Klasse hat alle Benachrichtigungen bereits eingebaut.

Merkwürdig ist auch, daß du den DataContext des Grids an das ausgewählte Element bindest, welchen Zweck soll das haben? Normalerweise muß man nur einmal bei der Initialisierung den DataContext des Fensters auf das MainViewModel setzen. Und wenn der nachträglich geändert wird, dann funktionieren die bestehenden Bindings nicht mehr.

Du könntest auch mal schauen, ob es einen Fehler im Ausgabefenster gibt, siehe dazu [Artikel] MVVM und DataBinding (Abschnitt Debugging).

Die Benennung deiner Klassen ist auch etwas verwirrend, normalerweise verwendet man keine Prefixe, sondern die ViewModels heißen einfach EmployeeViewModel oder CompanyViewModel oder so. Siehe dazu auch: [Artikel] C#: Richtlinien für die Namensvergabe

Und Datenbankabfragen sollten eigentlich nicht im ViewModel stattfinden, das würde ich auch mal noch an die richtige Stelle auslagern. Siehe dazu: [Artikel] Drei-Schichten-Architektur

  if (DateTime.Now == start)

Dieser Fall mit wird (mit großer Wahrscheinlichkeit) nie eintreten.

Verwende lieber einen Timer.

Kannst du bitte den Quelltext auf das Wesentliche reduzieren? Wo erstellst du die Liste und wo fügst du das Element zu der Liste hinzu?

Ansonsten schau mal in diesen Artikel: [Artikel] MVVM und DataBinding

eine Frage der Interpretation und des Geschmacks

Nee. Nur eine Frage der Funktionalität. Werden die Daten geändert und muß die UI über eine Änderung informiert werden, um die Bindings zu aktualisieren, braucht es ein ViewModel mit INotifyPropertyChange. Ansonsten nicht.

ist das wirklich so?

Ja. Die Erklärung dafür gibt es ja auch im verlinkten Artikel.

• Erstelle ich für das BaseViewModel, RelayCommand oder Klassen in den ich später SQL-Abfragen behandel ,eigene Klassen
  in der Projektmappe? Dieses und ähnliches prinzipielle Prozedere sind mir nicht transparent.

Entweder verwendest du eine fertige Bibliothek, oder du mußt die Klassen für das BaseViewModel und das RelayCommand selbst erstellen. Ist aber nicht viel Aufwand. Schau dir mal das Beispiel-Projekt in [Artikel] MVVM und DataBinding an.

• Wenn ich den Datakontext auf ein ViewModel gelegt habe (Mit demn Commands für die Buttons z.B.)
  aber noch eine weiteres ViewModel (eine Liste mit Daten) benötige, was dann?

Dann hat dein ViewModell eine Eigenschaft mit einer Liste von anderen ViewModels (und diese können auch wiederum Unter-ViewModells haben), siehe dazu den Abschnitt "2.4 ViewModel-Auflistungen" bzw. das Beispiel-Projekt.

-In der Anleitung (MVVM und DataBinding) ist der DataContext auf: <local:MainViewModel/> darauf wird aber im weiteren nicht Bezug genommen?

Nein, der DataContext ist immer implizit das Ziel für DataBindings, siehe FrameworkElement.DataContext Eigenschaft.

In [Artikel] MVVM und DataBinding gibt es auch Beispiel-Code und ein Beispiel-Projekt dazu.

Nachtrag:

In reinem HTML gibt es keine Möglichkeit, Templates für wiederkehrende Elemente wie Header, Menüs oder Footer zu definieren. Früher gab es mal Framesets, aber die sind inzwischen obsolet. IFrames sind dagegen nur zum Einbinden externer Resourcen zu verwenden, also meistens Werbung, und werden daher auch gerne mal von AdBlockern ignoriert.

Lösungen dafür gibt es je nach verwendeter Technologie:

Werden die Seiten auf dem Server gerendert, gibt es bei ASP.NET MVC PartialViews, bei PHP Includes etc. Man kann auch ein CMS wie WordPress etc. verwenden, dort kann man dann Templates für bestimmte Seitenbereiche definieren.

Wird die Seite auf dem Client gerendert, z.B. mit Angular, wird die Seite auch in Komponenten aufgeteilt, die dann kontextabhängig angezeigt oder nicht angezeigt werden können. Auch mit reinem JavaScript kann man Seitenelemente austauschen.

Willst du eine rein statische HTML-Seite erstellen, dann kannst du den CSS :target Selector verwenden, um Inhalte ein- oder auszublenden (und dabei sogar animierte Überblendungen anzeigen). Die URL www.deineseite.de#contact blendet dann das Kontaktformular ein und alles andere aus, www.deineseite.de#about die "Über mich"-Seite, und www.deineseite.de die Homepage. Der Rest der Seite (Header usw.) bleibt dabei stehen.

Vergiß das mit den Frames. Die brauchst du nur, wenn du externe Inhalte auf deiner Webseite einbinden willst. Fürs Layout gibt es andere Möglichkeiten, z.B. über Flexbox: A Complete Guide to Flexbox . Und Styles definiert man üblicherweise in einer CSS-Datei.

Verstehe ich nicht. Dieses Property ändert sich doch nicht automatisch. Und um es zu setzen, braucht man keinen Wrapper.

Und wenn es um DatanBinding geht und darum, daß der Benutzer den Watcher an- und ausschalten kann, braucht man halt ein ViewModel.

Du solltest dir die verlinkten Artikel wirklich mal anschauen, bevor du dich beschwerst. Abt hat die ja nicht für umsonst gepostet.

Ich glaube, dir ist nicht ganz klar, wie DataBinding funktioniert, und was ein Event ist.

DataBinding geht nur mit einer Eigenschaft. Ein Event informiert nur darüber, daß sich eine Eigenschaft geändert hat.

Schau dir mal diesen Artikel an, da ist erklärt, wie DataBinding funktioniert: [Artikel] MVVM und DataBinding

Im Grunde brauchst du ein ViewModel, das das Event vom FileSystemWatcher abonniert, und darauf reagiert, indem es eine Eigenschaft ändert, an die du deine Textbox gebunden hast. Ein UserControl oder eine Ableitung vom FileSystemWatcher sind hier nicht zielführend.

Bitte schau dir doch erstmal an, wie ein Forum funktioniert. Wir wissen nur, was du geschrieben hast, und können nur darauf antworten. Wenn du nicht schreibst, daß es sich um einen Benutzer eines Autos handelt, müssen wir davon ausgehen, daß du einen Benutzer der Anwendung oder der DB meinst.

Wenn du Hilfe benötigst, mußt du es deinen Helfern so einfach wie möglich machen, dazu gehört auch, gleich im richtigen Forenbereich zu posten.

Und Crossposts in anderen Foren dulden wir auch nicht.

Bitte lies dir mal [Hinweis] Wie poste ich richtig? durch.

Was den Benutzer betrifft: Du brauchst eine zusätzliche Tabelle mit den Benutzern, und in den anderen Tabellen eine Beziehung (Fremdschlüssel) zu einem Benutzer. Und in deinem Programm brauchst du eine Auswahl des aktuellen Benutzers, ob über Login-Formular oder etwas anderes.

Hört sich vielleicht auch komisch an, aber man könnte die Mitarbeiter ja auch mal befragen, was an dem Programm gut ist und was nicht so gut ist, bevor man eine firmenweite Überwachung ausrollt.

Woher kennt die SPA (vue.js) App den windows user?

Unter Angular reicht es, beim HttpClient die withCredentials-Eigenschaft auf true zu setzen. Dann werden die Credentials des aktuellen Benutzers an den Server weitergegeben. Wie das bei Vue funktioniert, weiß ich nicht.