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

完成。

这可能是老师要你做的。自己搞清楚这一点很有价值......对不起。

请注意，封装BooksCount是个好主意，您不希望意外地将其更改为错误的值...实际上，为什么不创建一个封装数组的类伯爵？好吧，这就是List<T>的工作原理（好吧，我没有告诉你如何插入，或者当你在阵列上用尽空间时该做什么，但你需要的是这篇文章中的所有内容，{{{ 1}}，你需要if s）。

啊，顺便说一下，有一个名为“链表”的结构，这是另一回事。

选项五：分配和复制

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

使用此定义：

if

您可以这样添加：

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;

测试。

完成。

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

不，你没有。即使正在更改阵列，也可以使用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;删除。我们回到这个定义：

Array.Copy

您可以删除以下内容：

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

这是一回事。您不必编写for循环。

删除C＃类的成员

1 个答案:

从数组中删除项目