Ed *_* S. 117
如果你需要一个动态大小的数组,我会使用List:
List<string> ls = new List<string>();
ls.Add("Hello");
Ali*_*söz 95
这可能是一个解决方案;
Array.Resize(ref array, newsize);
array[newsize - 1] = "newvalue"
但对于动态大小的数组我也更喜欢列表.
Ste*_*ung 52
使用LINQ:
arr = (arr ?? Enumerable.Empty<string>()).Concat(new[] { newitem }).ToArray();
我喜欢使用它,因为它是一个单行,非常方便嵌入switch语句,简单的if语句或pass作为参数.
编辑:
有些人不喜欢,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可能是您想要的数据结构,而不是要开始的数组.
art*_*r02 25
在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;
}
}
如您所见,它创建了一个具有新大小的新数组,复制源数组的内容并设置对新数组的引用.对此的提示是第一个参数的ref关键字.
有些列表可以为新项目动态分配新的插槽.这是例如List <T>.它们包含不可变数组,并在需要时调整它们的大小(List <T>不是链表实现!).没有Generics(使用Object数组),ArrayList是相同的.
LinkedList <T>是一个真正的链表实现.不幸的是,您只能将LinkListNode <T>元素添加到列表中,因此您必须将自己的列表元素包装到此节点类型中.我认为它的使用并不常见.
Gri*_*air 24
很老的问题,但仍然想添加这个.
如果您正在寻找单行,您可以使用下面的代码.它结合了接受可枚举的列表构造函数和"new"(自问题引发)初始化器语法.
myArray = new List<string>(myArray) { "add this" }.ToArray();
小智 22
Array.Resize(ref youur_array_name, your_array_name.Length + 1);
your_array_name[your_array_name.Length - 1] = "new item";
小智 8
所以如果你有一个现有的数组，我的快速修复将是
var tempList = originalArray.ToList();
tempList.Add(newitem);
现在只需用新数组替换原始数组
originalArray = tempList.ToArray();
自 .NET Framework 4.7.1 和 .NET Core 1.0 起Append<TSource>添加了一种新方法IEnumerable<TSource>。
以下是如何使用它：
var numbers = new [] { "one", "two", "three" };
numbers = numbers.Append("four").ToArray();
Console.WriteLine(string.Join(", ", numbers)); // one, two, three, four
请注意，如果您想在数组的开头添加元素，则可以改用 newPrepend<TSource>方法。
您可以使用基于LINQ的逻辑扩展@Stephen Chung提供的答案,以使用泛型类型创建扩展方法.
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();
你可以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;