# C#: Array ohne definierte länge:



## MSuter (5. September 2002)

Ich Programmiere seit kurzem C# und habe nun ein kleines Problem mit einem Array:

Also, ich wollte eine Funktion welche mir ein eindimensionales Array zurückgibt, soweit kein Problem:

Dieses Array fülle ich nun aber mit einer foreach Schleife, d.h., ich habe keine Ahnung wieviele einträge dieses Array hat.

Definiere ich das array nun mit "string[] resultat;", also ohne längenangabe, so lässt es der Debbuger nicht zu, dass ich das Array zum schluss mit "return resultat;" zurücksende!

Wie lässt sich dieses Problem lösen?

Gruss MSuter


----------



## goela (5. September 2002)

Da ich nicht genau weiss, was Du machen willst, hier mal zwei Beispiele, die Dich sicherlich weiterbringen!

*Beispiel 1: *
In diesem Beispiel wird *out * verwendet.


```
using System;

// cs_array_ref_and_out.cs
using System; 
class TestOut 
{
    static public void FillArray(out int[] myArray) 
    {
        // Initialisierung des arrays:
        myArray = new int[5] {1, 2, 3, 4, 5};
    }

    static public void Main() 
    {
        int[] myArray; // Initialisierung nicht erforderlich erforderlich

        // Array abfüllen:
        FillArray(out myArray);

        // Array ausgeben
        Console.WriteLine("Array elements are:");
        for (int i=0; i < myArray.Length; i++)
            Console.WriteLine(myArray[i]);
    }
}

Ausgabe:
Array elements are:
1
2
3
4
5
```

* Beispiel 2: *
In diesem Beispiel wird *ref * verwendet.

```
// cs_array_ref_and_out2.cs
using System; 
class TestRef 
{
    public static void FillArray(ref int[] arr) 
    {
        // Array bei Bedarf erstellen:
        if (arr == null)
            arr = new int[10];
        // Sonst Array füllen
        arr[0] = 123;
        arr[4] = 1024;
    }

    static public void Main () 
    {
        // Array Initialisieren:
        int[] myArray = {1,2,3,4,5};  

        // Array bei ref übergeben:
        FillArray(ref myArray);

        // Array ausgeben
        Console.WriteLine("Array elements are:");
        for (int i = 0; i < myArray.Length; i++) 
            Console.WriteLine(myArray[i]);
    }

}

Ausgabe:
Array elements are:
123
2
3
4
1024
```

Erklärung zu ref und out:

Bei der Verwendung von ref muss die Variable vorher initialisiert sein. Bei out ist dies nicht der Fall! In beiden Fällen erhälst Du Rückgabewerte. Also kannst Du auch so Dein Array zurückgeben.

Beispiel:

```
public void GetPoint(ref int x, ref int y)
    {
        x = this.x;
        y = this.y;
    }

    main....
    int x;
    int y;
    GetPoint(x, y); // Erzeugt Fehler

    int x = 0;
    int y = 0;
    GetPoint(x, y); // Richtig
```

Dies macht natürlich keinen Sinn, Werte vorher zu initialisieren, die dann sofort wieder überschrieben werden. Dazu ist es besser out zu verwenden.


```
public void GetPoint(out int x, out int y)
    {
        x = this.x;
        y = this.y;
    }

    main....
    int x;
    int y;
    GetPoint(x, y); // Kein Fehler
```


----------



## MSuter (6. September 2002)

*Leider nicht so einfach*

Deine Varianten funktionieren leider nicht da ich wie gesagt ein array unbestimmter läng brauche. In dieses Array fülle ich dann mit einer foreach schleife. Das ganze bezweckt in meinem Falle, dass ich eine Ganze Textdatei auslese und dabei jede Zeile der Textdatei ins Array geschrieben werden soll. das Problem besteht darin, dass diese Datei eine Variable Zeilenzahl hat, also kann ich nicht mit 
int[] myArray = {1,2,3,4,5};
initialisieren da ich hier nur die festen 5 werte eintragen kann. Main Array soll aber bis zum schluss folgendermassen aufgebaut sein:
myArray[0] = 1. Zeile der Datei
myArray[1] = 2. Zeile der Datei
myArray[2] = 3. Zeile der Datei
myArray[n] = n. Zeile der Datei
Ist sowas möglich? (Ein befehl um die anzahl Werte in einem Array zu ändern ohne den Inhhalt der vorhandenen zu verlieren würde bereits genügen!!

Gruss Marco


----------



## goela (7. September 2002)

Sorry wenn ich nochmal Nachfrage! Aber in den Beispielen habe ich nur zeigen wollen, wie Du ein Array mit *out* oder *ref* zurückgeben kannst!

Wie gross das Array letztendlich ist spielt doch keine Rolle! Ich werde mal versuchen ein Beispiel zu machen, wo ein Array mit unbestimmter Grösse zurückgegeben wird!


----------



## goela (7. September 2002)

So hier habe ich jetzt ein Beispiel, dass Deine Wünsche erfüllt! Falls nicht, bitte sagen!!  

Wenn ich Dein Problem richtig verstanden habe, dann löst Du dies am besten mit einer Collection sprich ArrayList! Dieses kann in der Grösse dynamisch wachsen!


```
using System;
using System.Collections;
class TestOut 
{
    static public void ReadFile(ref ArrayList myArray) 
    {
        // Simuliere hier Datei einlesen
        myArray.Add("Zeile 1");
        myArray.Add("Zeile 2");
        myArray.Add("Zeile 3");
        myArray.Add("Zeile 4");
        myArray.Add("Zeile 5");
        // usw.
    }

    static public void Main() 
    {
        ArrayList myArray = new ArrayList();

        // Hier wird die Datei eingelesen
        ReadFile(ref myArray);

        // Inhalt der Datei ausgeben
        Console.WriteLine("Array elements are:");
        foreach (string text in myArray)
        {
            Console.WriteLine(text);
        }
        
    }

}
```

Noch etwas! Wie willst Du eigentlich das Array mit foreach füllen? Mit foreach iterierst Du über ein Array bzw. eine Collection! Also müsstes Du zuerst die Grösse (Anzahl Zeilen der Datei) kennen, dass Array anlegen und dann könntest Du mit foreach Zeile für Zeile in das Array abfüllen!

Also deshalb die Variante mit einer ArrayList!
Na Problem gelöst?


----------



## MSuter (7. September 2002)

*Besser!! *

Soweit ich das sehe entspricht dieser Code schon eher meinen vorstellungen. Leider kann ich ihn jetzt gerade nicht Testen (Bin Hundsmüde und muss morgen früh raus). Aber es sieht nicht schlecht aus. Mein Problem bei der ganzen Sache war ja bloss dass ich die ArrayList nicht kannte! (Wie gesagt, bin absoluter N00b in C#)

Aber Danke schon mal, ich werde es gleich wenn ich wieder zuhause bin Testen (Montag)!


----------



## goela (7. September 2002)

Wird schon funktionieren!
Habe leider Anfangs gedacht, Du weisst nicht, wie Du das Array zurückgeben willst! Denn auch wenn das Array eine undefinierte Länge hat, so kannst Du selber in der Funktion das Array managen! Was natürlich keinen Sinn macht, da ja C# die Collections anbietet!
Erst als Du Dein Problem genauer beschrieben hast, konnte ich Dir die Lösung präsentieren!


----------



## MSuter (9. September 2002)

Vielen Dank, funktioniert wunderbar, aber gibts auch noch eine Funktion um die Lästigen Zeilenumbrüche wegzuschneiden? Oder muss ich da Substring verwenden?

Gruss MSuter


----------



## Stefan Hackbarth (6. Dezember 2010)

Es gibt die Funktion Array.Trim 

damit sollte es funktionieren


----------

