Danke für die schnellen Antworten!

ist XSL-FO eine Option?

Ich glaube, das ist das, wonach ich gesucht hatte. Eine Auszeichnungssprache für Druckdokumente. Ein erster Test hat gezeigt, daß es macht, was es soll. Jetzt werde ich mal ein komplexeres Layout umsetzen.

Danke!

Hallo allerseits,

ich bin auf der Suche nach einer Möglichkeit, PDF-Dateien aus Templates + Daten zu erstellen. Diese Dateien sollen mehrseitig, möglichst barrierefrei zugänglich sein, und mit Seiten-Headern und -Footern ausgestattet sein. Das ganze soll in einer ASP.NET Core Web-Anwendung unter Linux laufen.

Bisher haben wir dafür das Reporting-Tool von DevExpress verwendet. Dafür hat man das Layout in einem proprietären Editor zusammengefrickelt, und dann die Daten per "DataBinding" in das Layout gefrickelt. Im Zuge der Umstellung auf .NET 5 wollen wir davon wegmigrieren.

Ich war ein bißchen ernüchtert, nachdem ich diesen Artikel gelesen hatte: Creating A PDF In .NET Core. Jemand hat dort die aktuellen (2019) Möglichkeiten evaluiert. Die Kommentare darunter sind auch sehr aufschlußreich. Offenbar gibt es kein Tool von kostenlos bis extrem teuer, das unsere Anforderungen abdeckt. Entweder gibt es keine Lösung für .NET Core, oder es läuft nicht unter Linux, oder es werden bei Seitenumbrüchen die Hälfte der letzten Zeile auf Seite 1 und die andere Hälfte der Zeile auf Seite 2 gedruckt, was für professionelle Dokumente natürlich nicht akzeptabel ist.

Und alle Bibiotheken, die kein Templating unterstützen, wo man also jedes Element selbst auf der Seite positionieren muß, kommt für unsere Zwecke nicht in Frage.

Meine erste Idee war daher, ein HTML- bzw. Razor-Template zu verwenden, und das dann in einem Headless-Chromium-Browser auf dem Server in ein PDF zu rendern. Aber leider eignet sich HTML nicht als Druckformat, denn sich auf allen Seiten wiederholende Header und Footer werden z.B. derzeit nur mit sehr häßlichen Workarounds unterstützt.

Eine andere Idee ist, mit Hilfe des Open XML SDK ein Word-Dokument zu erstellen, und das dann mittels LibreOffice per Kommandozeile in ein PDF zu konvertieren. Das scheint die einzige Möglichkeit zu sein, die alle unsere Anforderungen abdeckt. Aber vom Aufwand her übertrifft das noch das Erstellen von DevExpress-Reports.

Hat jemand etwas ähnliches schon im Einsatz? Oder gibt es andere Ideen?

Ich verweise an der Stelle mal auf diesen Beitrag: Wie kann ich eine Collection von Dictionarys in einer Listview anzeigen?

……...Was für eine dumme und arrogante Antwort. Wie alt bist du? 10? Kein Wunder werden deutsche Foren gemieden wie die sau.

Das müssen wir hier nicht noch einmal wiederholen

Was heißt ohne Erfolg? Wenn es eine unbehandelte Ausnahme gibt, wird das entsprechende Ereignis ausgelöst.

Catch and display unhandled exceptions in your WPF app

Wenn du System.Reactive.Linq verwendest, kannst du die einfach die Events als Observable abonnieren und die Observable.Throttle-Methode verwenden. In der Doku gibt es ein Beispiel.

Die WebClient-Methoden sind aber schon asynchrone Methoden, die hast du in deinem Beispiel nicht. Du willst Code parallel ausführen. Dafür reicht im einfachsten Fall ein Aufruf von Parallel.ForEach.

Ich empfehle, dir mal die Doku zu Tasks, asynchroner Programmierung und der Parallel-Klasse bzw. PLinq durchzulesen, damit du verstehst, worum es geht. Asynchrone Programmierung und parallele Programmierung sind zwei unterschiedliche Sachen.

ich sehe gerade, dass die Applikation auf Q liegt, was nach Netzlaufwerk riecht.

Wenn es ein Netzlaufwerk ist, wird es mit Sicherheit daran liegen. Dann versuch mal, die Anwendung von einem nicht-Netzlaufwerk zu starten.

Ich weiß auch nicht, wie man dir da weiterhelfen sollte. Normalerweise ist die Herangehensweise immer die gleiche:* Zuerst erstellt man ein Datenmodell, mit dem man alle Funktionen und Berechnungen durchführen kann, die für das Programm benötigt werden

• Dann implementiert man die Funktionen mit Hilfe des Datenmodells
• Dann testet man alle Funktionen mit Hilfe von Unit-Tests
• Und zum Schluß erstellt man eine Benutzeroberfläche für das Programm.

Du willst die ersten Schritte auslassen, und mit dem letzten Schritt beginnen. Dann kommst du von einem Problem zum nächsten, und von einem Workaround zum anderen, und keiner kann mehr deine Herangehensweise nachvollziehen, oder deinen Code verstehen, um dir da weiterhelfen zu können. Überleg dir nur mal, an wie vielen Stellen du deinen Code anpassen müßtest, wenn sich die Spaltenbreite im DataGrid von 50 auf 100 Pixel ändern würde.

Niemand wird dich davon abhalten, so weiterzumachen. Aber dann kannst du halt auch keine Hilfe im Forum erwarten, weil niemand so arbeiten würde. Mit dem Debugger könntest du dich von Rechenschritt zu Rechenschritt hangeln, und nachvollziehen, was dein Code macht, und dann berichtigen. Siehe dazu [Artikel] Debugger: Wie verwende ich den von Visual Studio?

Empfehlen würde ich allerdings eine etwas strukturiertere Herangehensweise, und erstmal ein geeignetes Datenmodell zu erstellen. Dann kannst du deine Berechnungen so implementieren, daß sie für dich (und andere) auch in ein paar Wochen oder Monaten noch nachvollziehbar sind.

Mit foreach kann man jede Auflistung durchlaufen, die das IEnumerable- bzw. das generische IEnumerable<T>-Interface implementiert. Und ObservableCollection<T> implementiert IEnumerable<T>.

Die Eigenschaft VersandDaten, die du durchlaufen willst, ist aber vom Typ MainViewModel.VersandDaten, und diese implementiert nicht IEnumerable, das sagt die Fehlermeldung.

Was heißt "funktioniert nicht"? Welche Fehlermeldung bekommst du?

Siehe dazu [Hinweis] Wie poste ich richtig?, Punkt 5 "Problem genau beschreiben - inkl. genauer Fehlermeldung - und konkrete Fragen stellen"

Die vorgeschlagenen Lösungen sind im Grunde nur Workarounds für ein Problem, das es ohne DataGrid nicht gäbe.

Das Problem kommt daher, daß du in der View das DataGrid verwendest, und das dann wieder im ViewModel brauchst, um die Textblöcke zu positionieren.

Ein DataGrid braucht man, wenn man große Mengen an Daten anzeigen, sortieren, gruppieren usw. muß. Es ist nicht dafür gedacht, ein Layout zu erstellen. Besonders nicht, wenn man etwas _außerhalb _des DataGrids positionieren möchte, wie es bei dir der Fall ist.

Bei dir sind es offenbar wenige Daten, die in einem gleichmäßigen Raster dargestellt werden sollen. Und dann sollen in dem gleichen Raster zusätzliche Textblöcke eingefügt werden.

Dafür gibt es schon ein Steuerelement, nämlich das Grid. Und im ViewModel kannst du alles genauso konfigurieren, wie du es brauchst, und dann an die View binden. Siehe dazu meine vorherigen Beiträge.

Du hast jetzt alles im ViewModel implementiert, und greifst trotzdem vom ViewModel auf die View zu, indem du DataGridCellInfo verwendest.

Die Idee der Schichtentrennung ist doch eben, daß das ViewModel nicht die View kennt und das Model nicht das ViewModel etc.

Wenn du deinen Code mal mit Unit-Tests testen würdest, dann würdest du auch merken, wie wichtig so etwas ist. Siehe dazu [Artikel] Unit-Tests: Einführung in das Unit-Testing mit VisualStudio

Lies dir nochmal die Antworten oben und die verlinkten Artikel durch, dann wird es vielleicht klarer, was gemeint ist.

Ich würde nach wie vor davon abraten, dafür ein DataGrid zu verwenden. Das macht die Sache nur unnötig kompliziert.

Aber wie stelle ich denn fest, ob Start -und Endpunkte sich überschneiden ??

Das sind doch am Ende nur (wenn alles korrekt implementiert ist) zwei Vergleiche.
Wenn ein Endpunkt oder ein Startpunkt eines Panels größer als der Startpunkt **und **kleiner als der Endpunkt eines anderen Panels ist, dann überschneiden sie sich.

Meinst du:

myPanel.Controls.Clear();

Siehe die Dokumentation zur Control.ControlCollection.Clear-Methode.

Siehe dazu auch: [Tipp] Schau in die Doku! - Möglichkeiten der Informationsgewinnung

Siehe dazu auch gleich das erste Beispiel in [FAQ] NullReferenceException: Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt "Wie die NullReferenceException entsteht"

Im ViewModel kriege ich ja das ListView z.B. in einer foreach Schleife mehrmals instanziiert

Dann verwendest du ja kein Binding. Nimm stattdessen lieber ein ItemsControl, das du an eine ObservableCollection bindest. So wie in dem Beispiel von Wilfried, oder in den Beispielen in [Artikel] MVVM und DataBinding

Siehe dazu der von Abt verlinkte Hinweis: [Hinweis] Wie poste ich richtig?

Punkt 2.3

Full Quotes (also das vollständige Wiederholen des/eines vorangegangenen Beitrags als Zitat) sind nicht erwünscht

Wie könnte denn deiner Meinung nach eine solche Klasse gestaltet sein & welche Properties wären denn notwendig ?

Ich meine eine Datenstruktur, die es dir ermöglicht, deine Anwendungslogik zu implementieren. Hier also ein regelmäßiges Grid aus Zeilen und Spalten, um Zellen zu selektieren und mit Inhalten zu befüllen. Das hat ersteinmal nichts mit der Benutzeroberfläche zu tun, siehe dazu [Artikel] Drei-Schichten-Architektur

Mit dieser Datenstruktur kannst du dann die Positionen, Größen und Inhalte der Zellen direkt an die View binden, z.B. an ein Grid oder (wie vonTh69 vorgeschlagen) an eine Canvas.

Der Unterschied zwischen Grid und Canvas wäre, daß ein Grid nur regelmäßige Zeilen und Spalten besitzt, und Elemente in einem Canvas völlig frei positionierbar sind.

Aktuell komme ich bereits an dem Punkt nicht weiter, wie der Code zu gestalten ist, wenn die Textblöcke unterhalb meines Datagrids erstellt & positioniert werden.

Ich wüßte auch nicht, wie man das so implementieren würde. Deshalb hatte ich Vorschläge gemacht, wie es funktionieren könnte.

Wenn es einen Bindingfehler gibt, steht der während der Ausführung im Ausgabefenster bzw. auch (in VS 2019) im Fenster für die WPF-Bindingfehler.

Ansonsten kannst du dir die Inhalte im Live Visual Tree anschauen bzw. mit einem DebugConverter. Siehe dazu den Abschnitt "Debugging" im MVVM-Artikel.

Einfacher wäre evtl. bei einer Änderung direkt im ViewModel den Text anzupassen, und dann an die ComboBox.Text-Eigenschaft zu binden.

Die Logik (also welche Markierung zu welcher Positionierung der Textblöcke führt) hat nichts mit WPF zu tun. Dafür kannst du die Klassen anlegen, die die Zellen und die Markierungen repräsentieren, und dann dort die Texte positionieren. Die Abfrage, ob sich Textblöcke überlagern, oder in eine neue Zeile positioniert werden müssen, ist eigentlich relativ trivial. Du mußt halt nur schauen, ob sich die Start- und Endpositionen der vorhandenen Blöcke mit dem neuen Block überschneiden.

Zur Darstellung selbst würde ich wahrscheinlich nicht auf ein DataGrid zurückgreifen, weil es für einen anderen Zweck gedacht ist. Um solche Layouts zu erstellen, würde sich wahrscheinlich ein einfaches Grid in Kombination mit einem ItemsControl besser eignen. Dann kannst du Inhalte, Größen und Positionierungen von deinen ViewModels direkt an die View binden.

Für konkretere Tips müßtest du mal beschreiben, wo das Problem genau liegt.

Wenn dir die automatische Lösung nicht ausreicht, weil du mehrere Wörter kürzen (oder verändern willst) willst, dann mußt du es selbst implementieren.

Du mußt auf die Größenänderung des Fensters reagieren, und deine Texte entsprechend abändern. Dafür gibt es die Methoden der String-Klasse, wie bspw. SubString.

Wenn du DataBinding verwendest, kannst du einfach die Namen im ViewModel kürzen und die Änderungen werden automatisch von der View übernommen: [Artikel] MVVM und DataBinding

Hier gibt es eine ausführliche Einführung in MVVM mit Code-Beispielen: [Artikel] MVVM und DataBinding

Klicke ich den Button werden die Werte für FullName in der ListView und auch im Label sofort geändert - nur nicht im Textfeld der ComboBox.

Der Bereich ist frei beschreibbar, wenn du das nicht willst, dann setze die IsEditable-Eigenschaft der ComboBox auf False. Siehe dazu die Anmerkungen in der Doku zur ComboBox.

Das widerspricht der Idee des Projekte-Forums. Siehe dazu Lizenzbedingungen für die Projekte / Spezielle Regeln für Projekte-Threads:

In diesem Bereich soll der Nutzen der Leser deutlich im Vordergrund stehen und der Nutzen des Autors zurücktreten. Das Projekte-Unterforum ist also als Gelegenheit zu verstehen, der Community etwas (zurück) zu geben. Die geposteten Projekte sollte also möglichst fehlerfrei und sofort sinnvoll einsetzbar sein.

Der Beitrag wurde daher verschoben.

Das scheint mir alles ein bißchen viel Aufwand zu sein, um ein Icon anzuzeigen. WPF unterstützt Vektorgrafiken, die kann man (im Gegensatz zu Bitmaps) beliebig skalieren und einfärben.

Hier gibt es eine (von vielen) großen Icon-Sammlungen: Material Design Icons. Die kannst du frei verwenden, und es gibt für jedes Icon den XAML-Code für WPF-Programme, die du nur in deine Resourcen kopieren mußt.

Das wäre eine Lösung:

public string FilterQuery
{
  get => filterQuery;
  set 
  {
      if (filterQuery == value)
        return;
      filterQuery = value;
      NotifyOfPropertyChange(nameof(FilterQuery));
      NotifyOfPropertyChange(nameof(FilteredItems));
  }
}


public YourFilterItemType SelectedFilterItem
{
  // ...
}


public IEnumerable<YourItemViewModel> FilteredItems
{
  get
  {
      var result = allItems;
      if (!string.IsNullOrEmptyOrWhiteSpace(FilterQuery))
        result = result.Where(m => m.Name.ToLower().StartsWith(FilterQuery.ToLower));
      // ...
      return result;
  }
}

Eine andere Möglichkeit wäre es, ReactiveUI zu verwenden. Hier gibt es eine Einführung in das Arbeiten mit Collections mit ein paar Beispielen: ReactiveUI Handbook.

Edit:

Ich hab übersehen, daß du die Filter auf die SQL-Abfrage anwenden willst. In dem Fall solltest du statt allItems zu filtern, die Abfrage auf Basis der Rückgabe deiner Repository.Query-Methode anwenden. Das muß auch nicht im ViewModel stattfinden, sondern man kann das auch in einem Service kapseln, der die Filter-Parameter entgegen nimmt und die Resultate zurückliefert. Und die Abfrage dann auch möglichst asynchron ausführt.

Es ist schon sehr merkwürdig, daß dein Control die INotifyPropertyChanged-Schnittstelle implementiert. Wozu meinst du das zu benötigen?

Ansonsten ist es nicht hilfreich, einfach hier den gesamten Code zu posten, und zu hoffen, daß jemand das Problem für dich löst. Besser wäre, wenn du mal beschreibst, wo du Probleme hast, und wo du nicht weiter kommst. Siehe dazu [Hinweis] Wie poste ich richtig?

Es ist nicht so schwierig, ein hierarchisches Datenmodell an einen TreeView zu binden. Dazu sollte man aber die Grundzüge von MVVM verstanden haben. Siehe dazu [Artikel] MVVM und DataBinding

Ein eigenes UserControl ist dafür auch nicht erforderlich, lediglich ein HierarchicalDataTemplate.

Eine Schritt-für-Schritt-Anleitung gibt es hier: Populating Hierarchical Data In TreeView In WPF Using MVVM

Du kannst die ClipToBounds-Eigenschaft dafür verwenden. In XAML:

ClipToBounds="True"

Für frei positionierbare grafische Elemente eignet sich eine Canvas allerdings besser als ein Grid.

Ich würde auch empfehlen, die RenderTransform-Eigenschaft in XAML zu definieren, dann kannst du den Winkel direkt mit DataBinding an dein ViewModel binden. Siehe dazu: [Artikel] MVVM und DataBinding

Crossposts werden nicht geduldet, weder hier noch in anderen Foren. Daher ist hier zu.

Also wenn du dich so komplett weigerst, mal in die Doku zu schauen, wird das auf Dauer nichts.

Wenn ein Fehler oder unerklärliches Verhalten auftritt, ist die Doku der erste Anlaufpunkt. Dann hättest du auch gesehen, daß die XmlDocument.LoadXml-Methode keinen Pfad erwartet, sondern XML.

Und daß es mehrere Beispiele in der Doku gibt, wie man XML-Dateien auslesen kann.

Bitte beachte [Hinweis] Wie poste ich richtig?, besonders Punkt 1.
Und: [Tipp] Schau in die Doku! - Möglichkeiten der Informationsgewinnung

Wie gesagt:

Es gibt keinen Grund, an ActualWidth/ActualHeight zu binden, um in WPF ein Layout zu erstellen

Wenn man möchte, daß ein Grid-Element den verfügbaren Platz restlos ausfüllt, dann verwendet man ein \*, siehe dazu die Beschreibung und die Beispiele in der Doku zu GridLength.

Wenn man will, daß ein Steuerelement den verfügbaren Platz im übergeordneten Element vollständig ausnutzt, denn verwendet man HorizontalAlignment="Stretch" oder ein entsprechendes Layout-Element, bei dem das automatisch geht, siehe dazu der von mir gepostete Link weiter oben.

Alles andere ist nur Gefrickel, was dir auf Dauer viel mehr Arbeit macht, als dir mal die Beispiele in der Doku anzuschauen, und es dann richtig zu machen.

theoretisch denke ich, weiß ich wie es gemeint ist.
Aber es geht los, dass ich ein Problem habe, die Doku zu verstehen. Mir fehlt der Ansatz 😦
D.h. was muss ich in C# tun, damit ich ein Block abarbeiten kann und wie komme ich an das Bild.

Du mußt schon etwas konkreter werden, wenn du Hilfe brauchst. Ich verstehe das so, daß du weder weißt, wie man mit C# Dateien ausliest, noch die Dateibeschreibung verstanden hast. Ersteres ist in der Doku ausführlich beschrieben (in dem Link von Th69 gibt es ein Beispiel), und für den Dateiaufbau haben wir die gleichen Informationen wie du.

1. Bild parsen
   --> krieg ich hin

Bist du dir sicher? Denn so wie ich das verstehe, ist genau das der schwierige Teil. Ich zitiere mal aus der PDF-Datei:

Packed complex (data type 5)
This is used for the Fourier transform of real images, which have symmetric real parts and antisymmetric imaginary parts and thus can be stored in half the number of bytes that the equivalent complex picture would take. The format is somewhat strange. I have confused things further by using semper's coordinate system.

Das klingt für mich nicht, als würde man das mal eben an einem Nachmittag umsetzen.

Du sagtest, daß es schon Parser in C und Python gibt, dann wäre es das einfachste, den Code nach C# zu portieren.

Mich wundert es ein wenig, daß eine so einfache Sache wie die Validierung der eingegebenen Daten so kompliziert sein kann. Und ich verstehe wirklich nicht, wo das Problem liegt. Allerdings kann ich dazu auch nicht viel beitragen, weil ich wie gesagt ein DataGrid nicht für die Dateneingabe verwenden würde.

Wahrscheinlich klingt es erstmal nach weniger Arbeit, wenn man das gleiche Steuerelement für die Anzeige von Listen und die Bearbeitung verwendet, aber da unterschätzt man einfach die Komplexität, wie du gerade selbst feststellen kannst.

Es gibt auch nur sehr wenige Anwendungsfälle, wo der Benutzer gleichzeitig hunderte oder tausende Datensätze bearbeiten muß, z.B. eine Tabellenkalkulation oder Massenimporte. In allen anderen Fällen ist es aber eher ein UX-Antipattern.

Es wäre doch so viel einfacher, wenn bei einem (Doppel-)Klick auf einen Datensatz ein Bereich oder ein Fenster mit einem Detail-Formular aufgeht, wo der Benutzer den Datensatz editieren kann. Und erst wenn dort alle Daten fehlerfrei eingegeben wurden, dann werden die Änderungen übernommen, und die Liste aktualisiert.

Wenn das für dich aus irgendwelchen Gründen nicht in Frage kommt, dann könntest du die Validierung auch einfach im ViewModel durchführen und fehlerhafte Eingaben einfach ignorieren:

public string SomeProperty
{
  get => someProperty;
  set 
  {
    if (someProperty == value || string.IsNullOrEmpty(value))
      return;
    someProperty = value;
    OnPropertyChanged(nameof(SomeProperty));
  }
}

Mich wundert ja, daß es überhaupt so funktioniert. Wo wird denn in deinem Code das NotifyPropertyChanged-Ereignis ausgelöst? Poste doch mal dein ViewModel mit dem Code, wo du den Status änderst.

Ich habe deinen Beitrag mal ins Smalltalk-Forum verschoben, wegen fehlendem Zusammenhang mit dem Original-Beitrag.

Ich würde sogar behaupten, daß alle Beiträge, die mit "nen Kumpel" anfangen, allerhöchstens für das Smalltalk-Forum geeignet sind.

Was genau ist deine Frage? Was hast du schon probiert, und wo gab es Schwierigkeiten?

Schau dir doch bitte mal das Beispiel in der verlinkten Doku zum EventTrigger an.

Auch die Doku zu EventTrigger.SourceName ist eindeutig:

You can set this property to the name of any element within the scope of where the trigger collection (the collection that this EventTrigger is part of) is applied.

Dein Button wird außerhalb des Scopes liegen.

Kannst du bitte aufhören, bei jeder Frage den kompletten Code deines Programms zu posten? Es reicht, wenn du den relevanten Ausschnitt hier postest.

Viel wichtiger wäre gewesen, mal zu erklären, was du bisher probiert hast! Hast du das Nuget Package überhaupt installiert? Hast du dir mal das Beispiel-Projekt auf GitHub angeschaut?

Bitte beachte [Hinweis] Wie poste ich richtig?

<EventTrigger RoutedEvent="Canvas.Loaded">

Dein Trigger wird einmalig beim Loaded-Event der Canvas ausgelöst. Dort sollte wohl eher das Click-Event von deinem Button verwendet werden. Siehe dazu auch die Beispiele und die Anmerkungen in der Doku der EventTrigger.RoutedEvent-Eigenschaft.

Es gibt Docking-Libraries von den üblichen kommerziellen Herstellern, aber an OpenSource gibt es kaum etwas vergleichbares.

Ob du deine Panels von UserControl oder Window ableitest, sollte eigentlich keinen Unterschied machen.

Siehe dazu [Artikel] MVVM und DataBinding
Auch die Formatierung würde man im XAML definieren.

Da steht aber: "Oder alternativ mit Hilfe von XAML".
Alternativ 😃

kann man auch mehrere Klassen mit DataContext machen oder nur mit 1er Klasse?

DataContext kann nur ein Objekt zugewiesen werden. Normalerweise hat das Fenster ein MainViewModel, und die einzelnen Unterbereiche im Fenster dann spezielle Unter-ViewModels, welche als Eigenschaften im MainViewModel liegen. Das kann beliebig verschachtelt werden.

Ansonsten würde ich empfehlen, statt OnPropertyChanged("ButtonName") besser OnPropertyChanged(nameOf(ButtonName)) zu schreiben, weil dann die Bindung nicht verloren geht, wenn du die Eigenschaft mal umbenennst.

Und deine Binding_Klasse würde ich lieber MainViewModel oder ButtonViewModel nennen, dann ist klar, welche Aufgabe die Klasse hat.

public override string ToString()
{
  return "Dein Text";
}

Siehe dazu auch die Doku zur ToString-Methode

Dein ViewModel muß das INotifyPropertyChanged-Interface implementieren. Hier gibt es eine ausführlichere Erklärung dazu: [Artikel] MVVM und DataBinding

Bitte beachte [Hinweis] Wie poste ich richtig?
Den Anhang habe ich entfernt. Wenn du Code posten möchtest, dann nutze die C#-Tags und poste den relevanten Code im Beitrag.

Für Listen mit beliebiger Anzahl gibt es den Datentyp List<T>

Siehe auch [FAQ] Wie finde ich den Einstieg in C#?

Habe ich etwas offensichtliches übersehen?

Ja. Du solltest dir mal ein Einführungs-Tutorial von EF Core anschauen, bevor du loslegst. Da ist alles erklärt, was du hier versuchst.

Ich verstehe nicht, was das mit Sortierung zu tun haben soll. Sortieren bedeutet ja, die Werte in der Liste in eine bestimmte Reihenfolge zu bringen. Eine Permutation ist doch das genaue Gegenteil.

PS: "ein performanter Bruteforce-Algorithmus" ist eine Tautologie ein Widerspruch*, ich hoffe, das ist dir klar 😃

*Danke @witte

Niemand würde für ein Datumsfeld eine TextBox verwenden, dafür gibt es den DatePicker