c# - 删除类数组的成员 C#

Question

我知道有类似这个问题的问题，但我已经尝试了所有给出的答案，但它仍然无法在我的程序中运行。

我创建了一个类数组，可以跨不同的类访问，如下所示，

static public Book[] Books = new Book[5];

我已经实现了将成员添加到数组和更改数组中的成员的方法，但我无法删除数组中的成员。代码如下，

if (BookEntries >= 1 && DeleteItem == 1)
{ 
    ChangeSelected = true;
    Books[0].Remove() //Remove array member at position 0
    //Or also tried
    Books = Books.Where(val => val != 0).ToArray();
    //Or also tried
    Books.RemoveAt(0)
    Console.Clear();
    Console.WriteLine("----- Book {0} Has Been Deleted -----", DeleteItem);
}

任何帮助将不胜感激，如果您需要任何其他信息，请询问。干杯

Answer 1

从数组中删除一个项目

选项一:不使用数组。

你需要的是一个动态结构，这是一个已解决的问题，请让自己站在巨人的肩膀上使用List<T> :

static public List<Book> Books = new List<Book>();

你可以像这样添加项目:

Books.Add(item);

或插入它们:

Books.Insert(index, item);

然后你可以像这样删除项目:

var indexToRemove = 0;
Books.RemoveAt(indexToRemove);

完成。

列表在内部使用数组，就像，这实际上与您尝试做的事情相同，只是您不必这样做，因为它已经完成了。我希望你的老师教你重用代码。

选项二:使用列表作为代理。

根据权力，您无法像这样声明您的结构:

static public Book[] Books = new Book[5];

您可以使用 List<Book>作为中间步骤:

var indexToRemove = 0;
var list = new List<Book>(Books);
list.RemoveAt(indexToRemove);
Books = list.ToArray();

完成。

您使用了数组，所以这在技术上是正确的。记住，technically correct is the best kind of correct .

选项三:Linq。

有点复杂，您可以使用 Linq 按索引过滤项目...

var indexToRemove = 0;
Books = Books.Where((item, index) => index != indexToRemove).ToArray();

这很少是您想要做的，尽管在某些情况下它可能就足够了，但您可能仍然需要列表。

方案四:for循环。

这里的想法是你的数组的大小不是项目的数量，而是你可能拥有的最大容量。相反，您为项目数量存储一个单独的字段:

static public Book[] Books = new Book[5];
static public int BooksCount = 0;

要添加项目，您可以执行以下操作:

var index = BooksCount;
BooksCount++;
Books[index] = item;

要删除它们...您需要一个 for 循环:

var indexToRemove = 0;
for (int index = indexToRemove + 1; index < BooksCount; index++)
{
    Books[index - 1] = Books[index];
}
BooksCount--;
Books[BooksCount] = default(Book); // null?

好的，这是怎么回事？

假设您有五个元素的容量，并且您当前存储了四个元素:

+---+---+---+---+---+
| A | B | C | D |   |
+---+---+---+---+---+

并且您想删除第二个元素。您首先将每个元素复制到左侧第二个位置之后，直到到达最后一个元素:

+---+---+---+---+---+
| A | B | C | D |   |
+---+---+---+---+---+

=>
the second element is index 1 (remember we start at 0)    
=> indexToRemove = 1
=> index = indexToRemove + 1
=> index = 2

=>
index = 2, index is less than 4 (there are four elements)
copy element at index 2 to index 1
+---+---+---+---+---+
| A | C | C | D |   |
+---+---+---+---+---+

=>
index = 3, index is less than 4 (there are four elements)
copy element at index 3 to index 2
+---+---+---+---+---+
| A | C | D | D |   |
+---+---+---+---+---+

=>
index = 4, index is NOT less than 4 (there are four elements)

然后递减元素个数，并删除最后一个:

+---+---+---+---+---+
| A | C | D | D |   |
+---+---+---+---+---+

=>

+---+---+---+---+---+
| A | C | D |   |   |
+---+---+---+---+---+
There are three elements

完成。

这可能是您的老师希望您做的。自己解决这个问题很有值(value)……抱歉。

注意封装BooksCount是个好主意，你不想不小心把它改成错误的值……其实，你为什么不做一个封装数组和计数的类呢？嗯，就是这样List<T>有效(好吧，我没有告诉你如何插入，或者当你用完数组空间时该怎么做，但你需要的都在这篇文章中，而 if ，你需要 if s) .

啊，对了，还有一种叫做“链表”的结构，那是另外一回事。

方案五:分配和复制

您可以将您的数组视为实际上不可变的。在这种情况下，每个操作都会创建一个副本。这可能对并行性有好处...

使用这个定义:

static public Book[] Books = new Book[5];

你可以这样添加:

var replacement = new Book[Books.Length + 1];
Array.Copy(Books, 0, replacement, 0, Books.Length);
replacement[Books.Length] = item;
Books = replacement;

你可以这样插入:

var replacement = new Book[Books.Length + 1];
Array.Copy(Books, 0, replacement, 0, index);
replacement[index] = item;
Array.Copy(Books, index, replacement, index + 1, Books.Length - index);
Books = replacement;

已测试。

你可以这样删除:

var indexToRemove = 0;
var replacement = new Book[Books.Length - 1];
Array.Copy(Books, 0, replacement, 0, indexToRemove);
Array.Copy(Books, indexToRemove + 1, replacement, indexToRemove, Books.Length - indexToRemove - 1);
Books = replacement;

已测试。

完成。

选项七:我说过你需要一个 for 循环吗？

不，你不知道。您可以使用 Array.Copy即使正在更改数组也要删除。我们回到这个定义:

static public Book[] Books = new Book[5];
static public int BooksCount = 0;

您可以像这样删除项目:

Array.Copy(Books, indexToRemove + 1, Books, indexToRemove, BooksCount - indexToRemove - 1);
BooksCount--;
Books[BooksCount] = default(Book); // null?

其实是一样的。您不必编写 for 循环。