Klingt nach der schlechten Kombination von keine Backups sowie fehlenden Rücklagen.
Dadurch stand man schon auf wackligen Beinen, was nun zur Insolvenz der Firma führt.
Sind beides selbstgemachte Problem.

Deshalb sollte man immer bei IT eine Backup Strategie fahren, die einen absoluten Datenverlust weitestgehend ausschließen.

T-Virus

Welche Unterschiede gibt es den zwischen den Api Versionen in der Struktur?
Wenn diese nicht sonderlich groß wären, dann könntest die diese in der gleichen Klasse abdecken.
Falls es z.B. zu Breaking Changes kommt könntest du ggf. mit JToken arbeiten.

T-Virus

Und in der Dou steht auch dick als Note folgende:

Note: This method is only relevant in specific use cases and should only used by advanced programmers

Die Methode manuell aufrufen ist hier vermutlich auch der falsche Weg.
Da du dies in deinen Gettern machst, wird diese auch bei jedem Abrufen der Eigenschaften ausgelöst.
Dadurch tust du dir also keinen Gefallen und verbrennst durch häufige Updates dann zusätzliche Rechenzeit.

T-Virus

Am ende muss ja durch Where die Liste beim Materialisieren z.B. mit ToList() oder mit First/FirstOrDefault() durchlaufen werden.
Das kostet eben Zeit, hast du aber selbst schon bemerkt.

List<T> ist bei großen Listen als Container zum suchen nicht mehr praktikabel, da er alle Elemente durchlaufen muss.
Je nachdem wie man darauf sucht, muss er bei nicht gefundenen Treffern immer durch die ganze Liste laufen.
Wenn du schnell suchen willst und auch fixe Kriterien wie einen eindeutigen Key hast, dann nimm Dictionary und gruppiere damit deine Einträge.
Z.B. könntest du deine Enums als Keys verwenden und die Werte im Value als List<MyPrice> speichern.
Bei Änderungen musst du dann die Listen entsprechend bearbeiten.

Nachtrag:
Bezogen auf Update.
Die Methode wird in deinen Gettern aufgerufen und dann die Listen, Trends etc. geliefert.
Diese Methode sehe ich im Code aber nicht, weiß ich nicht was diese überhaupt macht.
Ansonsten sehe ich nur eine Stelle wo deine Preis Liste gefllt bzw. ein MyPrice Objekt hinzugefügt wird.

T-Virus

Und Slowly scheint Update aufzurufen, was nicht in deinem Code enthalten ist.
Auch ist gefühlt 90% des Code generiert und damit für externe Leute wie mich unbrauchbar.

Das ganze geht offensichtlich in die Richtung von Online Trading und Vergleichen von aktuellen Aktien Kursen, da die Namespaces auf NinjaTrader verweisen.
Vermutlich ist dann dein Ansatz mit dem durchlaufen der Liste schon falsch.
Du machst auch je nach Methode ein Where auf deine Listen.
Daduch kommt es unweigerlich bei großen Listen zu langen Suchzeiten.

Vermutlich wäre teilweise ein Ansatz das ganze mit Dictionary zu lösen.
Kannst du dann aber nur für einen Teil verwenden, sobald due mit Werten größer/kleiner suchen musst, funktioniert der Ansatz nicht mehr.

Link:
https://ninjatrader.com/de/

T-Virus

Ich verstehe immer noch nicht was dein Ziel ist oder sein soll.
Es macht ohne Kontext erstmal keinen Sinn, dass du 4.000 mal durch die Liste laufen musst.
Wenn dann auch noch Berechnungen mit den einzelnen Einträgen dauern können, wirst du um Wartezeiten nicht drum herum kommen.
Man könnte diese zwar noch mit Ansätzen wie Parallel.ForEach auf möglichst alle Kerne verteilen, aber das löst dein Grundproblem nicht.

Alleine mehrfach durch die Listen zu laufen klingt schon nach einem vollig falschen Ansatz.
Im Bestfall macht man es einmal und führt dann alle Operationen in einem Rutsch aus.
Allein dadurch würde man unmengen an unnützen Iterationen und damit Zeit einsparen.
Ebenfalls würde eine Gruppierung der Listen Einträge z.B. mit Dictionary die Suche dann verkürzen.

Aber ohne Kontext kann dir niemand sagen was du hier sinnvoll als Lösung machen kannst.
Bitte liefere Informationen dazu, damit man dies überhaupt mal beurteilen kann wo der Fehler liegt in deinem Konzept liegt.

T-Virus

Der Code an sich gibt eigentlich kein erkennbares Problem wieder.
Auch kann anhand des Snippets kaum ein Performance Problem auftreten.
Das du aber tausendfach durch die Liste läuft richt nach einem falschen Ansatz.

Mir ist auch nicht klar wie ein Performance Problem in deinem C# Code mit SQL gelöst werden sollte.
Ggf. fehlt uns hier Kontext, den du erläutern solltest.

Ansonsten wäre es auch hilreich zu wissen, warum du durch die Listen laufen musst.
Suchst du hier nach Einträgen oder musst du ggf. die Einträge ändern?
Wenn diese z.B. aus einer DB kommen, dann kannst du diese mit einem Update Befehl vermutlich sinnvoller updaten als ales einzuladen durchlaufen und dann zurück zu schreiben.

@ClaraSoft
Da er die Liste rückwärts durchläuft, wäre foreach hier nicht hilfreich.
Generell nimmt sich die for/foreach Schleife nur syntaktisch was.
Unter der Haube machen beide das gleiche.

T-Virus

Wenn ich wählen könnte würde ich fast immer zu Json greifen.
Ist gerade bei komplexen Strukturen kompakter als XML.

Hier solltest du dich in die Formate einlesen und für dich entscheiden welches dir besser passt.

T-Virus

@Abt
Steht auch so in der Doku:

Der Typ ist gefährlich und wird nicht für die BinaryFormatter Datenverarbeitung empfohlen.
++Anwendungen sollten so bald wie möglich aufhören, BinaryFormatter zu verwenden, auch wenn Sie der Auffassung sind, dass die verarbeiteten Daten vertrauenswürdig sind. ++
BinaryFormatter ist unsicher und kann nicht sicher gemacht werden.

Quelle:
Deserialisierungsrisiken in der Verwendung von BinaryFormatter- und verwandten Typen

T-Virus

Auch zu beim BinaryFormatter zu beachten, dass bei Änderungen an deiner Klasse die bestehenden Dateien nicht mehr deserialisiert werden können.
Du musst dann selbst für Kompatibilität sorgen z.B. duch Versionierung durch Vererbung.

T-Virus

Wenn die Abfrage im Kern immer gleich ist, dann ist es ein enormer Vorteil alles in einer Transaktion zu lösen.
Die Latenzen kommen auch zu einem nicht unbedeutenden Teil daher, dass z.B. die Anfrage erst über das Netz laufen muss und die Antwort wieder zurück.
Ebenfalls dauert auch die Verarbeitung der Anfrage, da diese vom SQL Server geparst und dann verarbeitet wird.

Wenn du auch SqlParameter verwendest, wovon ich erstmal ausgehen würde, dann sollte die Zusammenfassung dem SQL Server die Netzwerk sowie die Zeiten zum parsen der gleichen Abfragen ersparen.
Da du auch schon einen Index nuzt, kann die Ermittlung der passenden Einträge eigentlich auch nicht lange dauern.

Ich vermute, dass allein durch das Kapseln der Abfragen zu einer Transaktion die Zeiten nochmal fallen dürften.
Hat sich bei Massenupdates bei einigen Tausend Datensätzen, die per PK geupdatet wurde, enorm bemerkbar gemacht.
Auc spart man eben viel Ping/Pong zwischen Client und Server aus.

T-Virus

Die Frage wäre auch was bei euch Zeit frisst.
Wenn es quasi das Ping Pong zwischen Client und Server ist, dann kannst du dies durch zusammenfassen in einer Transaktionen verringern.
Wenn die Verarbeitung der Updates selbst die Zeit fisst, müste man eben wissen wie diese ausgeführt werden.
Wenn diese eben keinen Index verwenden, müssen auch große Tabellen seriell gelesen werden.
Das frisst dann nicht nur enorm die Performance sondern kann bei gleichzeiten Zugriffen zu Problemen und Wartzeiten führen.

Mein Gedanke mit dem OR Mapper war eher, dass durch Änderungen an den Objekten der OR Mapper selbst ermittelt welche Felder geupdatet werden müssen.
Dann würde er auch entsprechendes SQL generieren um nur diese Felder zu updaten.
Wenn aber dein SQL durch externe Dateien zusammen gezimmert wird, was mir erstmal nicht ganz geheuer ist, dann funktioniert dieser Ansatz nicht bzw. auch nur mit Aufwand.
Hier müsste man entsprechende Modelle anlegen, die schon dem DB Schema entsprechen.
Aber auch dann bleiben Probleme wie fehlender Index etc. als Performance Bremse vorhanden.

Mir ist aber noch nicht klar wie der Ablauf insgesamt ist.
Wie Abt schon schreibt, muss es ja ein Schema geben, da du nicht SQL mit unbekannten Tabellen/Spalten erstellst.
Dadurch ergibt sich ja schon ein gewisses Schema, die frage wäre nur grob wie dies aussieht.
Oder fahrt ihr hier z.B. eine Art Key/Value Struktur auf einer relationalen Datenbank?
Dafür gibt es dann bessere Ansätze als relationale Datenbanken im NoSQL Bereich.

Kannst du hier ein Sample für die Ini Datei und einer Update Abfrage liefern?
Vielleicht wird dann klarer was das Problem ist und wie man es ggf. anders/sauber löst.

T-Virus

Klingt fast nach dem Lösen eines Problems was z.B. durch OR Mapper bereits gelöst ist.
Wenn du nicht weißt welche Spalten geupdatet werden, dann klingt dies nach dynamischen Updates.
Sowas löst z.B. Entity Framework Core bereits für dich.

Ansonsten müsstest du einfach nur passende Update Anweisungen generieren.
Sind es mehrere, kannst du diese auch einfach in einer Transaktion sammeln und ausführen.

Die Frage ist allerdings was für ein Problem du konkret hast und was du damit lösen willst.
Wenn es ein Performance Problem ist, wie werden dann z.B. die Daten für das Update ermittelt (Where Klausel)?
Ggf. fehlt hier einfach ein Index?

T-Virus

@Abt
Ah okay, da lag ich dann falsch.

T-Virus

Hab noch weitere Punkte gefunden.

1. Du verwendest .NET 6.0 aber für Json Newtonsoft.Json, warum nicht System.Text.Json?
   Gerade bei .NET 5+ sollte man eher auf System.Text.Json setzen falls es keinen Fall gibt, den System.Text.Json nicht abdeckt.
   Für einfache De-/Serialisierung sollte es aber passen.

2. In deinen Modeln nutzt du scheinbar JToken für Values.
   Hast du hier kein eindeutiges Json bzw. sind die Objekte variabel?
   Falls nicht leg dafür eigene Klassen an, die dein Vaue abdecken.
   Hier reicht es wenn du das Json aus einer internen Instanz serialisierst.

3. Im DatabaseSettingsService hälst du eine Instanz des AppDbContext Instanz als Member.
   Die DbContext instanz sollte nur kurzlebig z.B. innerhalb einer Methode genutzt werden.
   Hast du im FileIndexerService besser umgesetzt.

T-Virus

Warum erstellst du den DbContext in der Schleife jedes mal neu?
Leg dir vor deiner File Schleife einen Context an und arbeite darauf.
Ansonsten wäre auch die Frage ob du deine Klasse nicht ggf. immer mit den gleichen Dateien aufrufst.
In dem Fall wäre auch klar warum immer mehr Dateien geändert werden.

Auch solltest du deinen Code überarbeiten.
Deine Methoden beginnen mit _ oder mal mit kleinen Buchstaben.
Die CompareLists Methode liefert Listen im Tuppel Format zurück.
Beides ist nicht wirklich schön zu lesen, letztes solltest du gerade im Sinne von Unit of Work in einem eigenen Objekt kapseln.

T-Virus

Wobei die Zukunft bei .NET und Json bei System.Text.Json liegt!
Ist aber ein anderes Thema.

T-Virus

Die nötigen Methoden der String Klasse sind IndexOf, LastIndexOf und Substring sein 🙂
Damit kannst du dann den Teil rauslösen.

T-Virus

Wie sieht den dein aktueller Code aus?
XML bearbeiten ist in .NET am besten Dokumentiert, dass du da nichts findest, halte ich auch für ein Gerücht.

Ansonsten hier ein Denkanstoß:
XmlNode.AppendChild

T-Virus

@M.L.
Für XNA gibt es MonoGame als Ersatz.
Die bauen auf der API auf, sind aber Platformunabhängig.
Man könnte also auch AntMe mit aktueller .NET Version und MonoGame usmetzen 🙂

T-Virus

Lässt sich bei Google mit ExecuteSqlCommand lösen.

Link:
https://www.learnentityframeworkcore.com/raw-sql

T-Virus

Ich den Code mal überflogen.
Aktuell ist dieser sehr suboptimal.
Dein Spielfeld ist ein struct mit öffentlichen Membern.
Leg dir eine Klasse an und nutze Eigenschaften (Properties),

Ebenfalls nutzt deine Klasse nur static Methoden, die eigentlich Teil des Spielfeld sein sollten.
Auch ist dein Code zu sehr abhängig von Eingaben/Ausgaben.
Sowas gehört natürlich nicht in Tests.
Deine Spielfeld Klasse muss hier entsprechende Methode anbieten ohne Abhängigkeiten zu Ein-/Ausgaben per Console.

T-Virus

Kleine Info:
Die Verkürzung der Haupt CS Datei ist nur Syntax Zucker.
Im Hintergrund wird die Klasse samt Main Methode generiert.
Ohne funktioniert es bei .NET eben nicht.

T-Virus

.NET und Java sind auch zwei Paar Schuhe, du solltest dich nochmal mit dem neuen .NET beschäftigt.
.NET Framework ist die alte Welt, die ist auf dem Weg des EoL in den nächsten Jahren.
Darauf sollte man keine neuen Projekte mehr aufbauen.
Alte Projekte sollte man nach .NET 5+ portieren.

Anbei solltest du die Preview dann auch nicht nutzen.
Da der Name schon sagt, dass es sich dabei nicht um eine fertige Version sondern nur eine Vorschau handelt, solltest du eher auf die aktuelle Stable Version .NET 6 gehen.
Dies lässt sich auch z.B. via winget einfach installieren.

So wie sich dein Post liest fehlen die dir Grundlagen der neuen .NET Welt komplett.
Die alten Ansätze sind eben mit dem Framework obsolete bzw. gibt es nur noch Übergangslösungen.
Aber auch diese Ansätze sollte man wenn möglich meiden und den aktuellen Way to Go verwenden!

T-Virus

Wäre vermutlich sinnvoller, wenn du eine Klasse für CustomerOrdner nach dem Json Format umsetzt.
Dann wird diese in beide Richtungen direkt hin und her gewandelt.
Oder muss das Feld ein String sein, weil es auch in der DB nur ein String ist?
Wäre ungünstig, weil du dann den String zusätzlich hin und her konvertieren müsstest.
Wenn das ganze Objekt als XML gespeichert wird, dann brauchst du eben nur eine CustomerOrdner Klasse mit den richtigen Feldern aufbauen.
Die De-/Serialisierung kümmert sich dann eigentlich um alles.

Nachtrag:
Ja das Feld muss als String gespeichert werden.
Ich würde denoch auf eine eigene Klasse umsetzen.

Damit kannst du dann die Konvertierung von Json -> Objekt -> Xml und umgekehrt über die De-/Serialisierung laufen lassen.
Ist zwar immer ein zusätzlicher Schritt, ist in dem Fall aber wohl nötig.

T-Virus

Müsste CustomerOrder nicht ein eigenes Objekt sein?
Vermutlich wurde es bei der Umwandlung wegen dem String Typ dann einfach 1:1 zu einem String umgewandelt.
Hast du ggf. ein Beispiel, ohne Kundendaten, für den Json String?
Dann lässt sich dies eigentlich erkennen, wenn der Wert für das Feld nicht Quotet ist.

T-Virus

Du könntest deine Abfrage auch durch ein Dictioanry mit der ID als Key und dem Bool als Value umstellen.
Dazu müsstest du alle Daten vorladen und pro ID aus den Daten dann deine Logik zur Prüfung durchführen.
Dann kannst du einfach mit TryGetValue den Bool Wert ermitteln.
Gibt TryGetValue zurück, müsst du dann nur den Fall wie bei einem false verarbeiten.

Dadurch sparst du dir auch die Einzelabfragen, die am meisten Performance kosten.
Ansonsten ist der Code, wie Abt auch schon schrieb, stark verbesserungswürdig.
Alleine deine if Verzweigungen mit Negierung sind einfach else Blöcke.
Aber auch die anderen Anmerkungen von Abt sollest du beachten um den Code in Nahe Zukunft noch sinnvoll warten zu können.

T-Virus

Mach es doch ganz simpel und leg für das Web einen Benutzer auf dem Server und dem NAS an.
Dieser sollte dann einfach über eine Freigabe auf die Daten zugreifen können, ganz normal via UNC Pfad mit Server und Freigabe.

Wir fahren auch einen ähnlichen Aufbau, wobei ausgelagerte historische Daten über eine Freigabe einfach aus Textdateien eingelesen und verarbeitet werden.
Sollte von der Umsetzung her kein Problem sein.

Ansonsten muss ich Abt zustimmen, nicht mal zum testen sollte man solche Systeme als Admin laufen lassen.
Die Regel gilt auch außerhalb von Web Anwendungen!
Im schlimmsten Fall wird das Testsystem einfach laufen gelassen und bildet damit ein Angriffsziel.
Damit gibt man sich quasi selbst zum Abschuss frei, was absolut unnötig und seit Jahren bekannt ist!

T-Virus

Wozu eine SQL Datenbank wie MySQL?
Du kannst die Daten einfach im Speicher halten, gehört zu den Grundlagen von C# und OOP im allgemeinen.
Ansonsten nimmt man für Anwendunen eher SQLite als embedded DB.

Je nachdem wie deine Spieler Klasse bzw. eher Spielfigur aussieht, sollte diese eine Eigenschaft Position haben.
Dort musst du dann die X/Y Position drin speichern.
Die Spielfiguren müssen dann ihr Spielfeld kennen und die entsprechenden Positionen liefern.
Bei Bewegungen musst du dann die Position, wenn diese züge gültig sind, dann verschieben.
Ist eigentlich simple Addition/Subtraktion mit X/Y Position.

T-Virus

Was du vermutlich gebrauchen kannst nennt sich XPath.
Damit kannst du dir die Nodes suchen und liefern lassen.

Select Nodes Using XPath Navigation

T-Virus

Klingt dann eher nach einer Ableitung von Stream als einen Wrapper.
Diese müsste dann intern bei Read ab der festen Position anfangen und bei der berechneten Länge abbrechen.
Dadurch müsstest du auch nicht deinen Code anpassen.

Anbei habe ich mal den Code überflogen.
Aktuell sind alle Klassen und Methoden static.
Deine static readonly Kosntanten solltest du mit const ausweisen, dafür ist es bei Kosntanten da.

Es gibt gerade durch static in deinem Code keine Interface oder abstrakte Klassen.
Dadurch müsstest du jede allgemeine Änderung auch händisch wieder mit statischen Methoden in alle Hash Klassen einbauen.
Hier solltest du dir per abstrakter Klasse und sogar per Interface eine gemeinsame Grundlage aufbauen.
Die Konkreten Implementierungen müssen nicht mal static sein.

T-Virus

Ich verstehe das Problem nicht ganz.
Du kannst doch einfach über Length - Position die Länge ausrechnen.
Damit kannst du dann die Leselänge einfach berechnen und einschränken.

T-Virus

Wenn du mit Stream arbeitest, kannst du auch die Position setzen.
Es wäre auch sinnvoll, wenn du die Daten blockweise liest und dann hasht, dann musst du nicht die ganze Datei lesen.
So macht man es auch mit den .NET Hash Klassen.

Doku zu Position aus Stream:
Stream.Position Eigenschaft (System.IO)

T-Virus

In WPF arbeitet man auch nicht im Codebehind wie es bei Winforms gemacht wird.
Dort wird mit DataBinding gearbeitet, hier solltest du dir die Grundlagen und Konzepte von WPF verinnerlichen.
Sonst wirst du ganz schnell von einem Problem zum nächsten Hüpfen, da du gegen die grundlegende Technik von WPF arbeitest.

Zwischen VB und C# liegen auch einige Welten.
C# bzw. eben die einzelnen Techniken wie WPF hat hier ganz unterschiedliche Ansätze, die man eben erstmal lernen muss.
In WPF solltest du dir z.B. mal das Pattern MVC und die Ableger MVP und MVVM anschauen um die Abläufe zu verstehen.
Anleitungen dafür findest du im Netz genügend.

T-Virus

@Palladin007
Hatte den Aufruf von SendAsync oben schon in SendPingAsync geändert 🙂
Aber danke nochmal für den Hinweis 🙂

Hier mein dotnet Fiddle dazu:
https://dotnetfiddle.net/GeoCcU

T-Virus

Kleiner Tip, du kannst mit SendPingAsync den Aufruf direkt mit einem eigenen Task starten.
Dann kann der Rest mit async/await gelöst werden.

Nachtrag:
Du kannst dann auch gleich Console.WriteLine in der async Methode ausführen.
Dann musst du nicht erst den String bauen und hin und her schieben nur für die Ausgabe.

Nachtrag 2:
Die Umsetzung könnte man auch mit Parallel.Foreach umsetzen.

T-Virus

Hier solltest du dir mal OAuth2 mit der WebAPI von Microsoft anschauen.
Dort gibt man dann im Header ein Token anstelle der Credentials mit.

Dok:
Sichern einer Web-API mit einzelnen Konten und lokaler Anmeldung in ASP.NET-Web-API 2.2

T-Virus

Eigentlich ist in der Doku das passende Beispiel dabei.
Du brauchst auch keine eigene while schleife, dafür kannst du mit WaitForExit auf das Ende des Prozess warten.
Ansonsten bekommst du über ReadToEnd auch alle Zeilen, dies musst du eigentlich nicht mehrfach aufrufen!

Link:
Process.StandardOutput Eigenschaft (System.Diagnostics)

Nachtrag:
Ebenfalls sollte dieser Part auch asynchron laufen, sonst blockiert deine Winforms Anwendung bzw. die UI.

FAQ:
[FAQ] Warum blockiert mein GUI?

T-Virus

Also in dem Code wird nichts entfernt.
Da du auch mit einem Socket arbeitest und die Daten dort direkt ausliest, kannst du auch selbst sehen, dass dort nichts entfernt wird.
Hast du den Code mal debuggt um sicherzustellen, dass im Server die Daten auch richtig ankommen?

Ansonsten fehlt der Code zum senden.
Ebenfalls solltest du für asynchrone Verarbeitung am besten async/await verwenden.
Socket bietet die entsprechenden Async Methoden und in der Doku ist auch alles gut dokumentiert.

Nachtrag:
In deinem else Block macht es keinen Sinn erneut BeginReceive aufzurufen.
Hier läuft deine Verarbeitung bereits asynchron.
Damit schiebst du eine weitere asynchrone Verarbeitung an, was unnötig ist und auch einen neuen Thread benötigt.

Anbei zeig auch den Versand Code sowie den Teil wo du das Objekt serialisiert.
Ggf. ist dort noch was falsch!

T-Virus

Credentials gehören NIE in den Code.
Dafür gibt es Secrets bzw. kann man die Credentials über entsprechende Klassen direkt von Windows verwalten lassen.
Sowas gehört auch nicht in eine Config o.ä.

Nachtrag:
how-to-store-and-retrieve-credentials-on-windows-using-c-sharp

Dort wird z.B. auf das NuGet Paket für den CredentialManager verwiesen.
Dies kapselt die entsprechenden OS Funktionen.
Dürfte für deine Zwecke Ideal sein.

T-Virus

Und zusätzlich kann man mit allen möglichen Ansätzen den RAM voll laufen lassen.
Un abhängig ob wir von List<byte> oder anderen Strukturen reden.

ISerializable habe ich in gut 15 Jahren vielleicht ein oder zwei mal verwenden oder nutzen müssen.
In der Regel kann man mit dem Serializable Attibute und einer ordentlichen Klasse nur für Serialisierung den Standard Fall herstellen.
Deshalb hatte ich dir auch empfohlen eine eigene Klasse ohne den Overhead von Third Party Code umzusetzen.
Ggf. verwalten diese auch nochmal intern eigene Zustände (Member) und erzeugen damit noch einen extra Overhead.

Je nachdem kannst du also noch Daten einsparen sowohl bei der Serialisierung bzw. Persistierung sowie bei der eigentlichen Datenhaltung im Speicher.
Ebenfalls kann man häufig durch Anpassung der Datentypen noch Speichernutzung vermindern.
Aber wie schon mehrmals gesagt müssten wir die genutzten Klassen kennen.

Auch insgesamt musst du mal aus deiner Denkweise rauskommen.
Aktuell hast du dich in ISerializable verbissen, weshalb schon viele weitere Ansätze komplett ausgeschlossen werden.
Dadurch nimmst du dir aber gerade mögliche Optionen, was dich selbst in deinen Möglichkeiten unnötig einschränkt.
Kannst du mit einer eigenen Klasse alles lösen.

T-Virus

@Stefan.Haegele
Und was ist mit Defender for Business?
https://www.microsoft.com/en-us/security/business/endpoint-security/microsoft-defender-business

Dürfte vermutlich deinen Anforderungen entsprechen 🙂
Man muss halt zwischen Privaten und Business Varianten unterscheiden.
Dann hat man schon eine bessere Situation.

Ich nutze privat auch den Defender, einfach weil die anderen Lösungen teilweise nur noch Werbeverseucht waren oder viel CPU Last erzeugen.
Der Defender erfüllt da schon ganz ordentlich seine Arbeit ohne weiter zu stören.

Leider fehlen mir Erfahrungen mit der Business Version.
Sieht aber erstmal solide aus.
Kann man ja testen 🙂

T-Virus

Irgendwie drehen wir uns hier im Kreis.
Reden wir nun von komplexen Datentypen wie Klassen oder um grundlegende Datentypen wie int/double?
Bisher lesen sich deine Antworten nicht umbedingt klar und eindeutig.
Dadurch ist eine richtige Lösung nicht wirklich lieferbar.

Da du mit einer Liste im Speicher arbeitest, kannst du die Daten eigentlich auch ohne Probleme in einer Sqlite DB speichern.
Mit einem fertigen OR Mapper wie EF Core wäre der Aufwand dann auch recht gering.
Die Daten einladen ist dann auch kein Kunststück.
Aber ohne die Klasse zu kennen, die du wegspeichern willst, ist das für uns alles nur raten und wir können dir keine Hilfe leisten.

Nachtrag:
Anbei klingt die Klasse, die du speichern willst, auch irgendwie wie nach unsauberen Code.
Wenn du bestimmte Daten wegen einer externen Klasse ausblenden musst, würde ich schon für die Serialisierung eine eigene Klasse anlegen.
Diese sollte auch nur die Daten enthalten, die du speichern/laden willst.
Den Rest kannst du dann einfach auf die eigentliche Klasse mappen z.B. mit AutoMapper.

Nachtrag 2:
Ebenfalls solltest du bei der Menge an Einträgen dir mal das Fliegengewicht Muster anschauen.
Ggf. löst dies auch dein Problem mit der Speichermenge.
Hängt aber davon ab ob du die Zustände der Einträge ohne Probleme/Aufwand auf das Muster anwenden kann.

Fliegengewicht (Entwurfsmuster)

T-Virus

Aus deinen Kommentaren ist leider nicht ersichtlich, was für Daten du nun speichern willst.
Wenn wir von Millionen von Objekten in einer Collection reden, ist ggf. der Ansatz schon falsch.

Je nachdem was du für Daten hast, kannst du ggf. mit einer NoSQL Datenbank besser fahren als mit einer Custom Lösung.
Ggf. könnte man eine einfache Dokumenten Datenbank mit Json/Bson als Format verwenden.
Oder ggf. auch die Daten in einem Key/Value Store wegspeichern.
Ein paar mehr Details und ggf. ein Beispiel oder Code wären für eine bessere Überlegung nicht verkehrt.

Ebenfalls sei darauf hingewiesen, dass der BinaryFormatter z.B. kein Freund von Änderungen an den Daten ist.
Dieser braucht strikt die gleiche Klassen Instanz beim Deserialisieren wie beim serialisieren verwendet wurde.
Ändert sich die Klasse, sind deine Daten nicht mehr lesbar.
Kann man dann nur über Versionierung der Klassen lösen.

Hier solltest du die nächst beste Lösung nehmen.

Anbei der Hinweis aus der Doku:

BinaryFormatter serialization is obsolete and should not be used. See
> for more information.

T-Virus

Das Problem bei Bson ist, dass dort z.B. die Feldnamen vollständig mit serialisiert werden müssen.
Dadurch hast du auch einen Overhead, der vermutlich größer sein dürfte.

Bson:
BSON

T-Virus

Für sowas würde ich, wenn es binär sein muss, auf Protobuf setzen.
Der .NET BinaryFormatter war in der Vergangenheit nicht das Optimum.

Doku:
https://developers.google.com/protocol-buffers/docs/csharptutorial

T-Virus

Die Anwendung läuft mit dem Rechten des Benutzers der diese startet.
Entsprechend wäre die Frage wie der Code aussieht und ob du sicherstellst, dass alles vorhanden ist (Ordner).
Zeigt am besten mal den Code, dann kann man dies ggf. prüfen.

T-Virus

Hast du schonmal den Debugger verwendet und geschaut was du zurückbekommst?
Ich tippe mal darauf, dass der String null ist, weil das Feld nicht richtig deserialisiert wird.
Dadurch wird dann auch nichts angezeigt.
Kannst du aber mit dem Debugger prüfen.

Nachtrag:
Laut Doku rufst du die Realtime Api auf.
Die liefert dir auch kein Location Objekt, sondern ein Current Objekt.

Doku:
[

Weather and Geolocation API - Free Weather and Geolocation API JSON and XML - WeatherAPI.com](https://www.weatherapi.com/docs/?PageSpeed=noscript#apis-realtime)

T-Virus

Im einfachsten Fall kannst du doch durch iterieren und merken der letzten Version die aktuelle ermitteln.
Dafür brauchst du nur eine for Schleife die ab der letzten Version die Folgeversionen ermittelt.
Die neu Version muss dann nur gemerkt werden, damit beim nächsten Durchlauf wieder die Folgeversion gesucht wird.

Sollte jetzt keine Raketenwissenschaft sein 🙂
Version kannst du dann in eine Textdatei schreiben.

T-Virus

Zusätzlich zu den Vordefinierten Encodings gibt es auch die Möglichkeit mit GetEncoding eine passende Codierung zu erhalten.
Aber auch dies steht in der Doku.

Link:
Encoding.GetEncoding Methode (System.Text)

T-Virus