Kann ich mehrere Arrays einer Methode automatisiert (nicht hard-coded) abarbeiten

Question

Hi!

Ich verwende in einer Methode mehrere String-Arrays, wie zum Beispiel

public static string[] ARB01 = new string[] {"5","8" ...};

public static string[] ARB02 = new string[] {"6","80" ...};

usw... .

Diese Arrays sollen in einer anderen Methode einzeln über eine Schleife abgearbeitet werden. Bisher kenne ich nur die Möglichkeit, die Arrays „hard-coded“ abzuarbeiten, was allerdings bei einer größeren Anzahl an Arrays sehr arbeitsintensiv ist mir und vor allem nicht sehr elegant erscheint.

Beispiel:

for (int i = 0; i <ARB01.Length; i++)
   {      ....  ;    }          
            

Und dann eine Schleife für ARB02 usw.

Über Reflection komme ich zwar auf die Namen etc. in dieser Methode heran, aber wie es dann weiter gehen kann, weiß ich nicht.

Herzlichen Dank im Voraus für hilfreiche Tipps oder ein Beispiel. Ich verwende VS 2012 Express.

---

Herzlichen Gruß vranky

Answer 1

Hallo vranky,

eine Möglichkeit wäre, die Abarbeitung der Arrays in eine seperate Methode auszulagern in welche du das zu bearbeitende Array als Parameter reingibst.

public static void DoSomething(string[] arrayToWork)
{
   if (arrayToWork == null)
      return;

   for (int i = 0; i<arrayToWork.Length; i++)
   {
      //Deine Logik
   }
}

Der Aufruf würde dann so aussehen:

DoSomething(ARB01);
DoSomething(ARB02);

Ansonsten könntest du die Arrays in eine Liste Verpacken und darüber iterieren.

Was hast du denn genau vor mit den Arrays?

Gruß

Stefan

Answer 2

Hallo,
ich würde wahrscheinlich ein Array von Arrays bzw. eine Liste von Arrays anlegen:

            string[][] arb = new string[3][];//Array mit 12 Arrays als Kind
            arb[0] = new string[] { "1", "B", "c" };//Arrays auffüllen
            arb[1] = new string[] { "5", "7", "2" };//Arrays auffüllen
            arb[2] = new string[] { "6", "42", "gfdh" };//Arrays auffüllen

            foreach (string[] array in arb)
            {
                //Array für Array abarbeiten
                Console.WriteLine(string.Join(" - ", array));
            }

Und hier noch als Liste:

            List<string[]> arb = new List<string[]>();//Liste von Arrays, dynamisch erweiterbar
            arb.Add(new string[] { "1", "B", "c" });//Array einfügen
            arb.Add(new string[] { "5", "876", "H4110" });//Array einfügen

            foreach(string[] array in arb)//Über foreach-Schleife
            {
                //Array für Array abarbeiten
                Console.WriteLine(string.Join(" - ", array));
            }

            for(int i=0;i<arb.Count ;++i)//Über for-Schleife
            {
                Console.WriteLine(string.Join(" - ", arb[i]));
            }

Nochfolgend noch eine Version mit 2 For-Schleifen:

            for(int i=0;i<arb.Length ;++i)//Für Liste Count statt Length nutzen
            {
                Console.WriteLine("---");
                for(int j=0;j<arb[i].Length ;++j)//Ellemente des inneren Arrays durch gehen
                {
                    Console.WriteLine("   " + arb[i][j]);
                }
            }

Ob du nun ein Array/Liste mit for oder foreach nutzt oer etwas ganz anderes hängt davon ab, was du genau vor hast.

---

Koopakiller [kuːpakɪllɐ] (Tom Lambert)
Webseite | Code Beispiele | Facebook | Twitter | Snippets   C# ↔ VB.NET Konverter
Markiert bitte beantwortende Posts als Antwort und bewertet Beiträge. Danke.

Answer 3

Hallo Stefan!

Herzlichen Dank für deine Antwort.

So wie du es beschrieben hast mache ich es jetzt. Wird ein neues Array angelegt, darf ich den Aufruf mit dem neuen Array nicht vergessen, sofern dieses Array "abgearbeitet" werden soll .

Vor habe ich, das jeweilige Array, Element für Element abzuarbeiten. Die Namen der Arrays stellen auch ein Auswahlkriterium dar (der nummerische Teil des Namens stellt bei mir ein Datum dar). Hier, für das Beispiel habe ich nur 01, 02 angeführt.

Beim Aufruf der Methode "DoSomething" muss als Parameter der Name des String-Arrays "hart-codiert" angeführt werden. Also, wenn weitere Arrays abgearbeitet werden sollen, ist für jedes Array der Aufruf durchzuführen.

Über ""Reflection" kann man zwar die Namen der Arrays in einem eigenen Array sammeln (zB.: NamenArr[]), jedoch sind diese vom Typ String und nicht von String[] und somit für einen "programmgesteuerten" Aufruf wie "DoSomething(NamenArr[i])" nicht geeignet.

Was ich aber wissen wollte war, ob dies mit c# überhaupt, bzw. eventuell über eine andere elegante Vorgangsweise möglich ist."

---

Herzlichen Gruß vranky

Answer 4

Wie du in meiner ersten Antwort sehen kannst, kannst du auf die inneren Arrays über den Index zugreifen.

Reflection ist in diesem Zusammenhang unnötig. Es bringt hier einfach nichts (Leistungstechnisch).

Kopiere einfach mal meine Codeausschnitte in ein neues Programm und sieh' dir die Variablen im Debugger an (Im Einzelschritt auf die Namen der Variablen zeigen).

Solltest du denoch über Strings auf die einzelnen Arrays zugreifen wollen, dann kannst du ein Dictionary<TKey,TValue> benutzen. TKey muss ein String und somit der Name sein. TValue ist vom Typ String[] und enthält das jeweilge Array. Die Benutzeung ist ähnlich zur normalen Liste. Die Add-Methode übernimmt den Namen und das Array. Zugreifen kannst du über den Indexer. Ein Beispiel dazu:

Dictionary<string, string[]> dic = new Dictionary<string, string[]>();//Dctionary anlegen
dic.Add("NameDesArrays", new string[] {"01","02", });//Array hinzufügen
string[] array = dic["NameDesArrays"];//Array abfragen

---

Koopakiller [kuːpakɪllɐ] (Tom Lambert)
Webseite | Code Beispiele | Facebook | Twitter | Snippets   C# ↔ VB.NET Konverter
Markiert bitte beantwortende Posts als Antwort und bewertet Beiträge. Danke.

Answer 5

Danke Tom für deine beiden Antworten und Beispiele. Ich werde mein Problem über "Dictionary<>" lösen.

---

Herzlichen Gruß vranky