清除数组的最有效方法是什么？

Question

I was looking through some old code of mine from when I just started programming, and saw this lovely gem:

int[] Answers = new int[4];

//Some amount of code later, inside a function
Answers[0] = Answers[1] = Answers[2] = Answers[3] = 0;

Now although it works, it doesn't look very efficient because of the 4 assignment operators, so I did some researching, and found some alternatives:

Array.Clear(Answers, 0, 4);
((IList)Answers).Clear();
Parallel.For(0, 4, index => Answers[index] = 0);

There are many others, for example a friend mentioned Buffer.BlockCopy and Enumerable.Repeat . Which of these is the most efficient, or if there's another that's more efficient, what is it?

Answer 1

What's the most efficient way to clear an array?

Efficiency depends on the context and the final goal of the code and how many items are in the array. The acquisition of memory locations might be faster than iterating over an array to clear it. Depending on the type of memory used to hold the data there have been optimized methods to Clear the list or array of data which usually is faster than doing it by hand.

---

With that said, though one rarely clears an array directly and simply lets the array be garbage collected (on off cycles for the most part) by creating a new array with the clean values of the array available.

Subsequently by adhering to better programming disciplines, one rarely specifies an array size to be created and cleared to have it be re-used.

For the re-use and array size creation paradigm can introduce subtle and non subtle errors in indexing and general operations. Because the safety of creating data lists (arrays) on the fly and adding into them (inserting) and letting the language handle the memory allocations/de-allocations of data is a much safer and more efficient method to handle data operations.

---

Hence making it pointless to clear any array for re-use. We no longer program on 8088 based machines where memory and processing times are at a premium. Frankly trying to optimize little code (and later maintaining that code either by the original coder or a new developer) for a majority of programming needs on a modern computer is foolish and wastes the valuable development time for a company.

That programmer's time is more expensive to a development organization than the savings of a few cycles of time which the user would most likely not notice anyway.