Ich würde als erstes einmal versuchen den Kanal zu wechseln - vielleicht hast du einen Nachbarn der "aggressiver" auf dem gleichen Kanal sendet.
Die Einstellung kannst du idR. unter "WLAN - Funkkanal" finden. Dort wird dir angezeigt, wieviel in den von dir belegten Kanälen los ist, und du siehst auch ob andere evtl. besser geeignet (weniger los) wären.

Also mal abgesehen davon, dass TCP und UDP die Protokolle deiner Wahl sein sollten ist mir dein Szenario noch nicht klar.
Sollen die Clients untereinander kommunizieren, oder ein Server das ganze managen (das wäre der "Normalfall"). Und mal abgesehen davon muss es einen "festen, bekannten Punkt geben" weil "anrufen ohne die Nummer zu kennen", wird dich sehr selten an das Ziel bringen, das du möchtest.
Eine Ausnahme gäbe es, wobei dann aber der Endpunkt nur ermittelt würde und im Anschluss doch wieder bekannt wäre - Broadcast, beliebt im UDP, mach aber nur Sinn in relativ kleinen Netzwerksegmenten ( also nicht im WWW ).

[auth.anonymous]
# enable anonymous access
enabled = true

[auth.basic]
enabled = false

Wenn du mit Organisationen arbeiten solltest (per Grafana eingerichtet)

# specify organization name that should be used for unauthenticated users
org_name = MyOrganization

# specify role for unauthenticated users (default Viewer)
org_role = Editor

    using var conn = new MySqlConnection(" .... ");
    using var cmd = conn.CreateCommand();
    using var da = new MySqlDataAdapter(cmd);

    using var ds = new DataSet();

    // Die SQLs würde ich mit Feldnamen versehen
    da.SelectCommand.CommandText = "SELECT * FROM releaseversionen";
    da.Fill(ds, "Release");
    da.SelectCommand.CommandText = "SELECT * FROM module";
    da.Fill(ds, "Module");
    da.SelectCommand.CommandText = "SELECT * FROM testfaelle";
    da.Fill(ds, "Tests");

    // Schon etwas old-school, heute benutzt man eher ORMs wie z.B. Dapper
    using var dvRelease = new DataView(ds.Tables["Release"]);
    using var dvModule = new DataView(ds.Tables["Module"]);
    using var dvTests = new DataView(ds.Tables["Tests"]);

    for (int iRelease = 0; iRelease < dvRelease.Count; dvRelease++)
    {
        var nodeRelease = new TreeNode(dvRelease[iRelease]["releaseVersion"].ToString());
        treeView1.Nodes.Add(nodeRelease );
        dvModule.Filter = $"releaseID={dvRelease[iRelease]["releaseID"]}";


        for (int iModule = 0; iModule < dvModule.Count; iModule++)
        {
            var nodeModule =new TreeNode(dvModule[iModule]["modul"].ToString());
            nodeRelease.Nodes.Add(nodeModule);
            dvTests.Filter = $"modulID={dvRelease[iRelease]["modulID"]}";
            
            for (int iTests = 0; iTests < dvTests.Count; iTests++)
            {
                var nodeTest = new TreeNode(dvTests[iTests]["testfall"].ToString());
                nodeModule.Nodes.Add(nodeTest);
            }
        }
    }

*sln => Solution, Sammlung mehrerer (u.U. unterschiedlicher) Projekte
*.csproj => Ein CSharp Projekt (beinhaltet alle Datei / DLL / Nuget Verweise und Einstellungen zum Projekt)
*.cs => Quelldateien
*.config => Konfigurationen die zur Laufzeit geladen werden (je nach Projekt)
*.json => siehe *.config
*.pubxml => Einstellungen für die Veröffentlichung

So, das waren mal die wichtigsten, denke ich

Mit Newtonsoft.Json und SystemLinq geht das z.B.

string input = @"
                {
                  ""badwords"": [""string1"", ""string2""]
                }
            ";

var myObject = Newtonsoft.Json.JsonConvert.DeserializeObject<MyObject>(input);

var wordlist = myObject.Badwords.ToList();

wordlist.Add("string3");
wordlist.Add("string4");

myObject.Badwords = wordlist;

var output = Newtonsoft.Json.JsonConvert.SerializeObject(myObject);

Console.WriteLine(output);

Mit diesem Object:

class MyObject
{
  public IEnumerable<string> Badwords { get; set; }
}

Der Artikel scheint interessant zu sein

https://geekflare.com/de/best-stock-market-api/

To reset the password for MySQL you first must create a new file with the following contents:

ALTER USER 'root'@'localhost' IDENTIFIED BY 'PASSWORD';

Where PASSWORD is the new password to be used. Save that file as ~/mysql-pwd.

Next, stop the MySQL daemon with the command:

sudo systemctl stop mysql

With the daemon stopped, issue the command:

sudo mysqld -init-file=~/mysql-pwd

Once your command prompt is returned, restart the MySQL daemon with the command:

sudo systemctl start mysql

You should now be able to log into the MySQL command prompt with the new admin password like so:

mysql -u root -p

https://www.strongdm.com/blog/how-to-change-the-mysql-root-password

Deine Varianten haben leider beide einen kleinen Denkfehler ...

Was ist denn wenn ary[0] bereits die kleinste Zahl ist?

Die Initialisierung hat dann den Effekt, dass smallest = secondsmallest und kein Wert mehr < smallest oder seconsmallest.

static Task<string> SchreibeAsync()
{
  return Task.Run(async() => 
  { 
    var text = "Hallo Telefon 123456";
    string path = @"{Directory.GetCurrentDirectory()}Test.txt";
    using (StreamWriter sw = new StreamWriter(path))
    {
      for (int i = 0; i < 50; i++)
      {
        await Task.Delay(100);
        sw.WriteLine(text);
      }
    }
    return path;
  });
}

// Aufruf innerhalb einer async Methode :
var datei = await SchreibeAsync();

So wäre dein Beispiel korrekt. Das Schlüsselwort ASYNC benötigt man nur, wenn innerhalb des folgenden Blocks ein AWAIT kommen wird - ansonsten ist es ein Task.

Im Grunde ist es so, dass aller Code abgearbeitet wird bis zu der Stelle an der das await kommt. Hier wird gewartet, da meist das Ergebnis in den folgenden Statements benutzt werden muss bzw. die Vorarbeit geleistet sein muss, bevor die weitere Ausführung stattfinden kann.

Übrigens instanziert man Task nicht mit "new" s.o.

Zunächst erstellst du dir eine Klasse, die von ICommand ableitet und als basis für deine Commands benutzt wird:

    public class RelayCommand : ICommand
    {
        private Action<object> m_Execute;
        private Func<object, bool> m_CanExecute;

        public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
        {
            m_Execute = execute;
            m_CanExecute = canExecute;
        }

        public bool CanExecute(object parameter)
        {
            return m_CanExecute == null || m_CanExecute(parameter);
        }

        public void Execute(object parameter)
        {
            m_Execute(parameter);
        }
    }

Jetzt kannst du in deinem ViewModel einen Command erstellen:

        private RelayCommand _CancelCommand;
        public RelayCommand CancelCommand
        {
            get
            {
                return _CancelCommand ?? (_CancelCommand = new RelayCommand(
                        (p) =>
                        {
                            // Hier kommt der eigentliche Code für das Click-Event rein.
                        },
                        (p) => { return true; // Enable / Disable }
                    ));
            }
        }

Und zum Abschluss bindest du diesen Command an deinen Button:

<Button Command="{Binding CancelCommand}">Abbrechen</Button>

Mit dem CommandManager evaluiert man neu, ob ein Button enabled / disabled ist (gesetz dem Fall, CanExecute retuniert nicht pauschal "true"):

CommandManager.RequerySuggested

Also ich persönlich bevorzuge ORM Mapper wie z.B. Dapper https://dapper-tutorial.net/dapper

Die Variante mit DataSet / DataTable sind in meinen Augen überholt.

Es gib auch noch das EntityFramework, das bei kleinen Datenmengen auch schnell zum Erfolg führt allerdings habe ich bei Massendatenverarbeitungen eher schlechte Erfahrungen gemacht.