it-swarm.com.de

arraygröße ändern

Ist es möglich, eine Arraygröße nach der Deklaration zu ändern? Wenn nicht, gibt es eine Alternative zu Arrays?
Ich möchte kein Array mit einer Größe von 1000 erstellen, aber ich weiß nicht, wie groß das Array ist, wenn ich es erstelle.

51
user522860

Nein, verwenden Sie stattdessen eine stark typisierte List .

Zum Beispiel:

Anstatt zu verwenden 

int[] myArray = new int[2];
myArray[0] = 1;
myArray[1] = 2;

Sie könnten das tun:

List<int> myList = new List<int>();
myList.Add(1);
myList.Add(2);

Listen verwenden Arrays, um die Daten zu speichern, sodass Sie mit dem Vorteil einer LinkedList den Geschwindigkeitsvorteil von Arrays nutzen können, indem Sie Elemente hinzufügen und entfernen können, ohne sich Gedanken darüber machen zu müssen, dass manuell seine Größe ändern muss.

Dies bedeutet jedoch nicht, dass die Größe eines Arrays (in diesem Fall eine List) nicht geändert wird - daher wird der Schwerpunkt manuell auf das Word gelegt.

Sobald Ihr Array seine vordefinierte Größe erreicht, weist das JIT ein doppeltes Array auf dem Heap zu und kopiert Ihr vorhandenes Array.

52
Corey Sunwold

Sie können Array.Resize() verwenden, dokumentiert in MSDN .

Aber ja, ich stimme mit Corey überein. Wenn Sie eine Datenstruktur mit dynamischer Größe benötigen, haben wir Lists dafür.

Wichtig: Array.Resize()ändert das Array nicht (der Methodenname ist irreführend), es erstellt ein neues Array und ersetzt nur das reference , das Sie an die Methode übergeben haben.

Ein Beispiel:

var array1 = new byte[10];
var array2 = array1;
Array.Resize<byte>(ref array1, 20);

// Now:
// array1.Length is 20
// array2.Length is 10
// Two different arrays.
55
Chris Shain

Sie können Array.Resize() in .net 3.5 und höher verwenden. Diese Methode ordnet ein neues Array mit der angegebenen Größe zu, kopiert Elemente aus dem alten Array in das neue und ersetzt dann das alte Array durch das neue ..__ verwendet Array.Copy unter den Umschlägen)

10
DerpDerp

Verwendete diesen Ansatz für ein Array von Bytes:

Anfänglich:

byte[] bytes = new byte[0];

Wann immer erforderlich (Originallänge zum Erweitern angeben):

Array.Resize<byte>(ref bytes, bytes.Length + requiredSize);

Zurücksetzen:

Array.Resize<byte>(ref bytes, 0);

Typisierte Listenmethode

Anfänglich:

List<byte> bytes = new List<byte>();

Wann immer erforderlich:

bytes.AddRange(new byte[length]);

Freigabe/Löschen:

bytes.Clear()
6
KbManu
5
kelloti

Verwenden Sie stattdessen einen List<T>. Zum Beispiel anstelle eines Arrays von Ints

private int[] _myIntegers = new int[1000];

benutzen

private List<int> _myIntegers = new List<int>();

später

_myIntegers.Add(1);
5
John Saunders

In C # können Arrays nicht dynamisch skaliert werden. 

  • Ein Ansatz ist die Verwendung von System.Collections.ArrayList stattdessen Eines native array.

  • Eine andere (schnellere) Lösung besteht darin, das Array mit einer anderen Größe von Erneut zuzuordnen und den Inhalt des alten Arrays in das neue Array Zu kopieren.

    Dazu kann die generische Funktion resizeArray (unten) verwendet werden. 

    public static System.Array ResizeArray (System.Array oldArray, int newSize)  
        {
          int oldSize = oldArray.Length;
          System.Type elementType = oldArray.GetType().GetElementType();
          System.Array newArray = System.Array.CreateInstance(elementType,newSize);
    
          int preserveLength = System.Math.Min(oldSize,newSize);
    
          if (preserveLength > 0)
          System.Array.Copy (oldArray,newArray,preserveLength);
    
         return newArray; 
      }  
    
     public static void Main ()  
           {
            int[] a = {1,2,3};
            a = (int[])ResizeArray(a,5);
            a[3] = 4;
            a[4] = 5;
    
            for (int i=0; i<a.Length; i++)
                  System.Console.WriteLine (a[i]); 
            }
    
5
sgokhales

In C # ist Array.Resize die einfachste Methode zum Ändern der Größe eines Arrays auf die neue Größe, z.

Array.Resize<LinkButton>(ref area, size);

Hier möchte ich die Arraygröße des LinkButton-Arrays ändern:

<LinkButton> = gibt den Arraytyp an
ref area = ref ist ein Schlüsselwort und 'area' ist der Arrayname
size = Array mit neuer Größe

4
Rajesh Londhe

Ja, es ist möglich, die Größe eines Arrays zu ändern. Zum Beispiel:

int[] arr = new int[5];
// increase size to 10
Array.Resize(ref arr, 10);
// decrease size to 3
Array.Resize(ref arr, 3);

Wenn Sie ein Array mit der CreateInstance () - Methode erstellen, funktioniert die Resize () - Methode nicht. Zum Beispiel:

// create an integer array with size of 5
var arr = Array.CreateInstance(typeof(int), 5);
// this not work
Array.Resize(ref arr, 10);

Die Array-Größe ist nicht dynamisch, selbst wenn wir die Größe des Arrays ändern können. Wenn Sie ein dynamisches Array wünschen, können wir stattdessen eine generische Liste verwenden.

var list = new List<int>();
// add any item to the list
list.Add(5);
list.Add(8);
list.Add(12);
// we can remove it easily as well
list.Remove(5);
foreach(var item in list)
{
  Console.WriteLine(item);
}
3
HENG Vongkol
    private void HandleResizeArray()
    {
        int[] aa = new int[2];
        aa[0] = 0;
        aa[1] = 1;

        aa = MyResizeArray(aa);
        aa = MyResizeArray(aa);
    }

    private int[] MyResizeArray(int[] aa)
    {
        Array.Resize(ref aa, aa.GetUpperBound(0) + 2);
        aa[aa.GetUpperBound(0)] = aa.GetUpperBound(0);
        return aa;
    }
3
user2235895

Verwenden Sie eine Liste (wobei T ein beliebiger Typ oder Objekt ist), wenn Sie Daten hinzufügen oder entfernen möchten, da die Größenänderung von Arrays teuer ist. Sie können mehr über Arrays lesen, die als schädlich gelten während eine Liste zu Neuen Datensätzen hinzugefügt werden kann. Es passt seine Größe nach Bedarf an. 

Eine Liste kann auf folgende Weise initialisiert werden

Sammlungsinitialisierer verwenden.

List<string> list1 = new List<string>()
{
    "carrot",
    "fox",
    "Explorer"
};

Verwenden des Schlüsselworts var mit dem Auflistungsinitialisierer.

var list2 = new List<string>()
{
    "carrot",
    "fox",
    "Explorer"
};

Neues Array als Parameter verwenden.

string[] array = { "carrot", "fox", "Explorer" };
List<string> list3 = new List<string>(array);

Kapazität in Konstruktor und Zuweisung verwenden.

List<string> list4 = new List<string>(3);
list4.Add(null); // Add empty references. (Not Recommended)
list4.Add(null);
list4.Add(null);
list4[0] = "carrot"; // Assign those references.
list4[1] = "fox";
list4[2] = "Explorer";

Verwenden der Add-Methode für jedes Element.

List<string> list5 = new List<string>();
list5.Add("carrot");
list5.Add("fox");
list5.Add("Explorer");

So können Sie für eine Objektliste die Eigenschaften von Objekten innerhalb der Listeninitialisierung zuordnen und zuweisen. Objektinitialisierer und Sammlungsinitialisierer weisen eine ähnliche Syntax auf.

class Test
{
    public int A { get; set; }
    public string B { get; set; }
}

Liste mit Sammlungsinitialisierer initialisieren.

List<Test> list1 = new List<Test>()
{
    new Test(){ A = 1, B = "Jessica"},
    new Test(){ A = 2, B = "Mandy"}
};

Liste mit neuen Objekten initialisieren.

List<Test> list2 = new List<Test>();
list2.Add(new Test() { A = 3, B = "Sarah" });
list2.Add(new Test() { A = 4, B = "Melanie" });
1

Falls Sie Array.Reset nicht verwenden können (die Variable ist nicht lokal), hilft Concat & ToArray:

anObject.anArray.Concat(new string[] { newArrayItem }).ToArray();
0
Miq

Dies hat gut funktioniert, um aus einem Klassenarray ein dynamisches Array zu erstellen.

var s = 0;
var songWriters = new SongWriterDetails[1];
foreach (var contributor in Contributors)
{
    Array.Resize(ref songWriters, s++);
    songWriters[s] = new SongWriterDetails();
    songWriters[s].DisplayName = contributor.Name;
    songWriters[s].PartyId = contributor.Id;
    s++;
}
0
PhillipPDX

Wenn Sie es wirklich in ein Array zurückholen müssen, finde ich es am einfachsten, array in list zu konvertieren. Erweitern Sie die Liste und konvertieren Sie sie zurück in array.

        string[] myArray = new string[1] {"Element One"};
        // Convert it to a list
        List<string> resizeList = myArray.ToList();
        // Add some elements
        resizeList.Add("Element Two");
        // Back to an array
        myArray = resizeList.ToArray();
        // myArray has grown to two elements.
0
clamchoda