Rekursive Methoden Aufrufe

Hallo zusammen,

ich muss diesen Code Teil:

private static void FilterData(stMDF_output output)
{
     List<int> validPts = new List<int>();

     for (int i = 0; i < filterList[0].Length; i++)
     {
        for (int n = 0; n < filterList[1].Length; n++)
        {                
           for (int j = 0; j < output.time.Timestamp.Count; j++)
           {
              double val0 = output.grp[filterList[0].Grp].Signal[filterList[0].Grp_pos][j];
              double val1 = output.grp[filterList[1].Grp].Signal[filterList[1].Grp_pos][j];
              double val2 = output.grp[filterList[2].Grp].Signal[filterList[2].Grp_pos][j];

               string mode0 = filterList[0].SmBi[i];
               string mode1 = filterList[1].SmBi[n];
               string mode2 = filterList[2].SmBi[0];

               bool valid0 = filterList[0].lineFilter(val0, mode0, i);
               bool valid1 = filterList[1].lineFilter(val1, mode1, n);
               bool valid2 = filterList[2].lineFilter(val2, mode2);

               if (valid0 && valid1 && valid2)
               {
                  validPts.Add(j);
               }                    
           }  
                 
        }
    }

      Debug.WriteLine(validPts.Count);                  
}

dynamisch erzeugen können. Die Einträge in der FilterListe werden ebenso dynamisch erzeugt. Somit muss ich beliebig viele ineinander verschachtelte For-Schleifen dynamisch erzeugen können (die innerste bleibt mit for (int j = 0; j < output.time.Timestamp.Count; j++) gleich. Ich denke das muss irgendwie mit Rekursiven Methoden Aufruf gehen aber ich checke nicht wie. Vielleicht kann mir jemand weiter helfen.

Danke und Gruß Bit

Ich hab dein Scenario mal in Mini nach gebaut:

var array = new[] { 2, 2, 2 };

for (int i = 0; i < array[0]; i++)
{
    for (int j = 0; j < array[1]; j++)
    {
        for (int k = 0; k < array[2]; k++)
            Console.WriteLine($"{i}{j}{k}");
    }
}

Rekursiv könnte man das so machen:

private static void DoSomethingRecursive(int[] array)
{
    DoSomethingRecursive(array, 0, new int[0]);
}
private static void DoSomethingRecursive(int[] array, int outerIndex, int[] innerCounters)
{
    // ist der outerIndex größer oder gleich der array-Länge, dann ist der innerste Bereich erreicht
    if (outerIndex >= array.Length)
    {
        // tue irgendwas mit allen for-Zählern, die in innerCounters stehen
        Console.WriteLine(string.Concat(innerCounters.ToArray()));
    }
    else
    {
        // weitere for-Schleife mit outerIndex starten
        for (int i = 0; i < array[outerIndex]; i++)
        {
            // neues Indices-Array erzeugen und den neuen for-Zähler hinzufügen
            // Eine Liste darf nicht verwendet werden, da sie ein Referenz-Typ ist
            var newInnerIndices = new int[innerCounters.Length + 1];
            innerCounters.CopyTo(newInnerIndices, 0);
            newInnerIndices[innerCounters.Length] = i;

            // rekursiver Aufruf:
            DoSomethingRecursive(array, outerIndex + 1, newInnerIndices);
        }
    }
}

Der erste Aufruf muss die erste Überladung nutzen.

Das erzeugt beides folgende Ausgabe:

000
001
010
011
100
101
110
111

Versuchs mal damit:
Rekursion mit Foreach

Super vielen Dank für die Antworten!
Das werde ich umsetzen. Vielleicht muss ich mich aber morgen nochmal melden 😃

Es funktioniert super!!!

Vielen Dank!