เพิ่มรายการใหม่ในอาร์เรย์ที่มีอยู่ใน c # .net

จะเพิ่มรายการใหม่ในอาร์เรย์สตริงที่มีอยู่ใน C # .net ได้อย่างไร?

ฉันต้องการเก็บรักษาข้อมูลที่มีอยู่

ฉันจะใช้รายการถ้าคุณต้องการอาร์เรย์ขนาดไดนามิก:

List<string> ls = new List<string>();
ls.Add("Hello");

นั่นอาจเป็นทางออก

Array.Resize(ref array, newsize);
array[newsize - 1] = "newvalue"

แต่สำหรับอาร์เรย์ขนาดไดนามิกฉันต้องการรายการด้วย

ใช้ LINQ:

arr = (arr ?? Enumerable.Empty<string>()).Concat(new[] { newitem }).ToArray();

ฉันชอบใช้สิ่งนี้เพราะมันเป็นหนึ่งซับและสะดวกมากในการฝังในคำสั่งสวิตช์คำสั่ง if แบบง่ายหรือส่งผ่านเป็นอาร์กิวเมนต์

แก้ไข:

บางคนไม่ชอบnew[] { newitem }เพราะมันสร้างอาร์เรย์ชั่วคราวขนาดเล็กรายการเดียว นี่คือเวอร์ชันที่ใช้Enumerable.Repeatซึ่งไม่จำเป็นต้องสร้างวัตถุใด ๆ (อย่างน้อยก็ไม่ใช่บนพื้นผิว - ตัวทำซ้ำ. NET อาจสร้างวัตถุเครื่องสถานะจำนวนมากใต้ตาราง)

arr = (arr ?? Enumerable.Empty<string>()).Concat(Enumerable.Repeat(newitem,1)).ToArray();

และถ้าคุณแน่ใจว่าอาร์เรย์ไม่เคยnullขึ้นต้นด้วยคุณสามารถทำให้อาร์เรย์ง่ายขึ้นเพื่อ:

arr.Concat(Enumerable.Repeat(newitem,1)).ToArray();

โปรดสังเกตว่าหากคุณต้องการเพิ่มรายการในคอลเลกชันที่สั่งซื้อListอาจเป็นโครงสร้างข้อมูลที่คุณต้องการไม่ใช่อาร์เรย์ที่จะเริ่มต้นด้วย

คำถามเก่ามาก แต่ยังต้องการเพิ่มสิ่งนี้

หากคุณกำลังมองหาซับเดียวคุณสามารถใช้รหัสด้านล่างนี้ มันรวมตัวสร้างรายการที่ยอมรับการแจงนับและไวยากรณ์ตัวเริ่มต้น "ใหม่" (ตั้งแต่ยกคำถาม)

myArray = new List<string>(myArray) { "add this" }.ToArray();

อาร์เรย์ใน C # จะไม่เปลี่ยนรูปเช่น,string[] int[]นั่นหมายความว่าคุณไม่สามารถปรับขนาดได้ คุณต้องสร้างอาร์เรย์ใหม่

นี่คือรหัสสำหรับArray.Resize :

public static void Resize<T>(ref T[] array, int newSize)
{
    if (newSize < 0)
    {
        throw new ArgumentOutOfRangeException("newSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    }
    T[] sourceArray = array;
    if (sourceArray == null)
    {
        array = new T[newSize];
    }
    else if (sourceArray.Length != newSize)
    {
        T[] destinationArray = new T[newSize];
        Copy(sourceArray, 0, destinationArray, 0, (sourceArray.Length > newSize) ? newSize : sourceArray.Length);
        array = destinationArray;
    }
}

ดังที่คุณเห็นว่าสร้างอาร์เรย์ใหม่ที่มีขนาดใหม่คัดลอกเนื้อหาของอาร์เรย์ต้นทางและตั้งค่าการอ้างอิงไปยังอาร์เรย์ใหม่ คำแนะนำนี้คือคีย์เวิร์ดอ้างอิงสำหรับพารามิเตอร์แรก

มีรายการที่สามารถจัดสรรสล็อตใหม่สำหรับรายการใหม่แบบไดนามิก นี้เป็นเช่น<T> List เหล่านี้ประกอบด้วยอาร์เรย์ที่ไม่เปลี่ยนรูปและปรับขนาดได้เมื่อจำเป็น (รายการ <T> ไม่ใช่การใช้รายการที่เชื่อมโยง!) ArrayListเป็นสิ่งเดียวกันที่ไม่มี Generics (พร้อมObject array)

LinkedList <T>เป็นการใช้งานรายการที่เชื่อมโยงจริง น่าเสียดายที่คุณสามารถเพิ่มเพียงองค์ประกอบ LinkListNode <T> ในรายการดังนั้นคุณต้องรวมองค์ประกอบรายการของคุณเองลงในประเภทโหนดนี้ ฉันคิดว่าการใช้งานมันผิดปกติ

 Array.Resize(ref youur_array_name, your_array_name.Length + 1);
 your_array_name[your_array_name.Length - 1] = "new item";

คุณสามารถขยายคำตอบโดย @Stephen Chung ได้โดยใช้ตรรกะตาม LINQ ของเขาเพื่อสร้างวิธีการขยายโดยใช้ประเภททั่วไป

public static class CollectionHelper
{
    public static IEnumerable<T> Add<T>(this IEnumerable<T> sequence, T item)
    {
        return (sequence ?? Enumerable.Empty<T>()).Concat(new[] { item });
    }

    public static T[] AddRangeToArray<T>(this T[] sequence, T[] items)
    {
        return (sequence ?? Enumerable.Empty<T>()).Concat(items).ToArray();
    }

    public static T[] AddToArray<T>(this T[] sequence, T item)
    {
        return Add(sequence, item).ToArray();
    }

}

จากนั้นคุณสามารถเรียกมันได้โดยตรงบนอาร์เรย์เช่นนี้

    public void AddToArray(string[] options)
    {
        // Add one item
        options = options.AddToArray("New Item");

        // Add a 
        options = options.AddRangeToArray(new string[] { "one", "two", "three" });

        // Do stuff...
    }

เป็นที่ยอมรับว่าเมธอด AddRangeToArray () ดูเหมือนจะใช้งานมากเกินไปเนื่องจากคุณมีฟังก์ชันการทำงานเดียวกันกับ Concat () แต่ด้วยวิธีนี้โค้ดสุดท้ายสามารถ "ทำงาน" กับอาร์เรย์ได้โดยตรงเมื่อเทียบกับสิ่งนี้:

options = options.Concat(new string[] { "one", "two", "three" }).ToArray();

จะดีกว่าที่จะทำให้ Array ไม่เปลี่ยนรูปและขนาดคงที่

คุณสามารถจำลองAddโดยExtension MethodและIEnumerable.Concat()

public static class ArrayExtensions
    {
        public static string[] Add(this string[] array, string item)
        {
            return array.Concat(new[] {item}).ToArray();
        }
    }

หากคุณใช้งานอาร์เรย์เป็นจำนวนมากและไม่ได้แสดงรายการด้วยเหตุผลบางประการวิธีการทั่วไปที่พิมพ์โดยทั่วไปนี้Addอาจช่วยได้

    public static T[] Add<T>(T[] array, T item)
    {
        T[] returnarray = new T[array.Length + 1];
        for (int i = 0; i < array.Length; i++)
        {
            returnarray[i] = array[i];
        }
        returnarray[array.Length] = item;
        return returnarray;
    }

คำตอบที่เสนอทั้งหมดทำเช่นเดียวกับสิ่งที่พวกเขาบอกว่าต้องการหลีกเลี่ยงสร้างอาร์เรย์ใหม่และเพิ่มรายการใหม่ในนั้นโดยที่สูญเสียค่าโสหุ้ยมากขึ้นเท่านั้น LINQ ไม่ใช่เวทย์มนตร์รายการของ T คืออาร์เรย์ที่มีพื้นที่บัฟเฟอร์ที่มีพื้นที่พิเศษเพื่อหลีกเลี่ยงการปรับขนาดอาร์เรย์ภายในเมื่อมีการเพิ่มรายการ

นามธรรมทั้งหมดต้องแก้ปัญหาเดียวกันสร้างอาร์เรย์โดยไม่มีช่องว่างที่เก็บค่าทั้งหมดแล้วส่งคืน

หากคุณต้องการความยืดหยุ่นสามารถสร้างรายการที่มีขนาดใหญ่พอที่คุณสามารถใช้เพื่อส่งผ่านได้ให้ทำเช่นนั้น อื่นใช้อาร์เรย์และแบ่งปันวัตถุที่ปลอดภัยของเธรดนั้น นอกจากนี้ Span ใหม่ยังช่วยแชร์ข้อมูลโดยไม่ต้องคัดลอกรายการรอบ ๆ

เพื่อตอบคำถาม:

Array.Resize(ref myArray, myArray.Length + 1);
data[myArray.Length - 1] = Value;

ดังนั้นหากคุณมีอาร์เรย์อยู่แล้วการแก้ไขด่วนของฉันจะเป็น

var tempList = originalArray.ToList();
tempList.Add(newitem);

ตอนนี้เพียงแค่แทนที่อาร์เรย์เดิมด้วยอาร์เรย์ใหม่

originalArray = tempList.ToArray();

Append<TSource>มีการเพิ่มวิธีการใหม่ในIEnumerable<TSource>ตั้งแต่. NET Framework 4.7.1 และ. NET Core 1.0

นี่คือวิธีการใช้งาน:

var numbers = new [] { "one", "two", "three" };
numbers = numbers.Append("four").ToArray();
Console.WriteLine(string.Join(", ", numbers)); // one, two, three, four

โปรดทราบว่าหากคุณต้องการเพิ่มองค์ประกอบที่จุดเริ่มต้นของอาร์เรย์คุณสามารถใช้Prepend<TSource>วิธีการใหม่แทนได้

การใช้รายการจะเป็นตัวเลือกที่ดีที่สุดสำหรับการจัดการหน่วยความจำ

แล้วการใช้วิธีการขยายล่ะ? ตัวอย่างเช่น:

public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> source, TSource item)
{
    return source.Union(new TSource[] { item });
}

ตัวอย่างเช่น:

string[] sourceArray = new []
{
    "foo",
    "bar"
}
string additionalItem = "foobar";
string result = sourceArray.Union(additionalItem);

สังเกตว่านี่เป็นการเลียนแบบลักษณะการทำงานของส่วนขยาย Uniion ของ Linq (ใช้เพื่อรวมอาร์เรย์สองอาร์เรย์เข้าด้วยกันเป็นอาร์เรย์ใหม่) และต้องการให้ไลบรารี Linq ทำงาน

ฉันเห็นด้วยกับเอ็ด C # ไม่ทำให้เรื่องนี้ง่ายเหมือนที่ VB ทำกับ ReDim Preserve หากไม่มีคอลเล็กชันคุณจะต้องคัดลอกอาร์เรย์ให้ใหญ่ขึ้น

string str = "string ";
List<string> li_str = new List<string>();
    for (int k = 0; k < 100; i++ )
         li_str.Add(str+k.ToString());
string[] arr_str = li_str.ToArray();

private static string[] GetMergedArray(string[] originalArray, string[] newArray)
    {
        int startIndexForNewArray = originalArray.Length;
        Array.Resize<string>(ref originalArray, originalArray.Length + newArray.Length);
        newArray.CopyTo(originalArray, startIndexForNewArray);
        return originalArray;
    }

ทำไมไม่ลองใช้คลาสStringbuilder มันมีวิธีการเช่น. insert และ. append คุณสามารถอ่านเพิ่มเติมได้ที่นี่: http://msdn.microsoft.com/en-us/library/2839d5h5(v=vs.71).aspx

น่าเสียดายที่การใช้รายการไม่สามารถใช้ได้ในทุกสถานการณ์ รายการและอาร์เรย์แตกต่างกันจริง ๆ และไม่สามารถใช้แทนกันได้ 100% มันจะขึ้นอยู่กับสถานการณ์ว่านี่จะเป็นการแก้ปัญหาที่ยอมรับได้หรือไม่

เนื่องจากคำถามนี้ไม่พอใจกับคำตอบที่ให้มาฉันจึงขอเพิ่มคำตอบนี้ :)

public class CustomArrayList<T> 
 {  
   private T[] arr;  private int count;  

public int Count  
  {   
    get   
      {    
        return this.count;   
      }  
   }  
 private const int INITIAL_CAPACITY = 4;  

 public CustomArrayList(int capacity = INITIAL_CAPACITY) 
 {  
    this.arr = new T[capacity];   this.count = 0; 
  } 

 public void Add(T item) 
  {  
    GrowIfArrIsFull();  
   this.arr[this.count] = item;  this.count++; 
  }  

public void Insert(int index, T item) 
{  
 if (index > this.count || index < 0)  
    {   
      throw new IndexOutOfRangeException(    "Invalid index: " + index);  
     }  
     GrowIfArrIsFull();  
     Array.Copy(this.arr, index,   this.arr, index + 1, this.count - index);          
    this.arr[index] = item;  this.count++; }  

    private void GrowIfArrIsFull() 
    {  
    if (this.count + 1 > this.arr.Length)  
    {   
      T[] extendedArr = new T[this.arr.Length * 2];  
      Array.Copy(this.arr, extendedArr, this.count);  
      this.arr = extendedArr;  
    } 
  }
 }
}