blocks|key|1432332|text|如果您不想使用List：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1432333|var+foos+=+new+List<Foo>(array);
foos.RemoveAt(index);
return+foos.ToArray();|code-block|syntax|javascript|1432334|你可以尝试这个我没有实际测试过的扩展方法：|1432335|public+static+T[]+RemoveAt<T>(this+T[]+source,+int+index)
{
++++T[]+dest+=+new+T[source.Length+-+1];
++++if(+index+>+0+)
++++++++Array.Copy(source,+0,+dest,+0,+index);

++++if(+index+<+source.Length+-+1+)
++++++++Array.Copy(source,+index+%2B+1,+dest,+index,+source.Length+-+index+-+1);

++++return+dest;
}|1432336|并像这样使用它：|1432337|Foo[]+bar+=+GetFoos();
bar+=+bar.RemoveAt(2);|1432338|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If you don't want to use List:

<pre><code>var foos = new List&lt;Foo&gt;(array);
foos.RemoveAt(index);
return foos.ToArray();
</code></pre>

You could try this extension method that I haven't actually tested:

<pre><code>public static T[] RemoveAt&lt;T&gt;(this T[] source, int index)
{
 T[] dest = new T[source.Length - 1];
 if( index &gt; 0 )
 Array.Copy(source, 0, dest, 0, index);

 if( index &lt; source.Length - 1 )
 Array.Copy(source, index + 1, dest, index, source.Length - index - 1);

 return dest;
}
</code></pre>

And use it like:

<pre><code>Foo[] bar = GetFoos();
bar = bar.RemoveAt(2);
</code></pre>

blocks|key|1647176|text|数组的本质是它们的长度是不可变的。您不能添加或删除任何数组项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1647177|您必须创建一个少了一个元素的新数组，并将旧项复制到新数组中，但不包括要删除的元素。|1647178|因此，使用列表可能比使用数组更好。|1647179|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The nature of arrays is that their length is immutable. You can't add or delete any of the array items.

You will have to create a new array that is one element shorter and copy the old items to the new array, excluding the element you want to delete.

So it is probably better to use a List instead of an array.

blocks|key|1647361|text|我使用此方法从对象数组中删除元素。在我的情况下，我的数组长度很小。因此，如果您有大型数组，则可能需要另一个解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1647362|private+int[]+RemoveIndices(int[]+IndicesArray,+int+RemoveAt)
{
++++int[]+newIndicesArray+=+new+int[IndicesArray.Length+-+1];

++++int+i+=+0;
++++int+j+=+0;
++++while+(i+<+IndicesArray.Length)
++++{
++++++++if+(i+!=+RemoveAt)
++++++++{
++++++++++++newIndicesArray[j]+=+IndicesArray[i];
++++++++++++j%2B%2B;
++++++++}

++++++++i%2B%2B;
++++}

++++return+newIndicesArray;
}|code-block|syntax|javascript|1647363|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I use this method for removing an element from an object array. In my situation, my arrays are small in length. So if you have large arrays you may need another solution.

<pre><code>private int[] RemoveIndices(int[] IndicesArray, int RemoveAt)
{
 int[] newIndicesArray = new int[IndicesArray.Length - 1];

 int i = 0;
 int j = 0;
 while (i &lt; IndicesArray.Length)
 {
 if (i != RemoveAt)
 {
 newIndicesArray[j] = IndicesArray[i];
 j++;
 }

 i++;
 }

 return newIndicesArray;
}
</code></pre>

blocks|key|1432646|text|LINQ单行解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1432647|myArray+=+myArray.Where((source,+index)+=>+index+!=+1).ToArray();|code-block|syntax|javascript|1432648|该示例中的1是要删除的元素的索引--在本例中，根据原始问题，是第二个元素(其中1是C#基于零的数组索引中的第二个元素)。|offset|length|style|CODE|1432649|一个更完整的例子：|1432650|string[]+myArray+=+{+"a",+"b",+"c",+"d",+"e"+};
int+indexToRemove+=+1;
myArray+=+myArray.Where((source,+index)+=>+index+!=+indexToRemove).ToArray();|1432651|运行该代码段后，myArray的值将为{+"a",+"c",+"d",+"e"+}。|1432652|entityMap^0|0|0|5|1|13|1|0|0|0|8|7|J|M|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@$I|14|J|15|K|L]|$I|16|J|17|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

LINQ one-line solution:

<pre><code>myArray = myArray.Where((source, index) =&gt; index != 1).ToArray();
</code></pre>

The <code>1</code> in that example is the index of the element to remove -- in this example, per the original question, the 2nd element (with <code>1</code> being the second element in C# zero-based array indexing).

A more complete example:

<pre><code>string[] myArray = { "a", "b", "c", "d", "e" };
int indexToRemove = 1;
myArray = myArray.Where((source, index) =&gt; index != indexToRemove).ToArray();
</code></pre>

After running that snippet, the value of <code>myArray</code> will be <code>{ "a", "c", "d", "e" }</code>.

blocks|key|1432514|text|这是一种删除数组元素的方法，从.Net+3.5开始，无需复制到另一个数组-在Array.Resize中使用相同的数组实例|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1432515|public+static+void+RemoveAt<T>(ref+T[]+arr,+int+index)
{
++++for+(int+a+=+index;+a+<+arr.Length+-+1;+a%2B%2B)
++++{
++++++++//+moving+elements+downwards,+to+fill+the+gap+at+[index]
++++++++arr[a]+=+arr[a+%2B+1];
++++}
++++//+finally,+let's+decrement+Array's+size+by+one
++++Array.Resize(ref+arr,+arr.Length+-+1);
}|code-block|syntax|javascript|1432516|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb348051.aspx^0|12|C|12|C|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

This is a way to delete an array element, as of .Net 3.5, without copying to another array - using the same array instance with <a href="http://msdn.microsoft.com/en-us/library/bb348051.aspx"><code>Array.Resize&lt;T&gt;</code></a>:

<pre><code>public static void RemoveAt&lt;T&gt;(ref T[] arr, int index)
{
 for (int a = index; a &lt; arr.Length - 1; a++)
 {
 // moving elements downwards, to fill the gap at [index]
 arr[a] = arr[a + 1];
 }
 // finally, let's decrement Array's size by one
 Array.Resize(ref arr, arr.Length - 1);
}
</code></pre>

blocks|key|1432376|text|这是我的一个旧版本，它可以在.NET框架的1.0版本上工作，不需要泛型类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1432377|public+static+Array+RemoveAt(Array+source,+int+index)
{
++++if+(source+==+null)
++++++++throw+new+ArgumentNullException("source");

++++if+(0+>+index+%7C%7C+index+>=+source.Length)
++++++++throw+new+ArgumentOutOfRangeException("index",+index,+"index+is+outside+the+bounds+of+source+array");

++++Array+dest+=+Array.CreateInstance(source.GetType().GetElementType(),+source.Length+-+1);
++++Array.Copy(source,+0,+dest,+0,+index);
++++Array.Copy(source,+index+%2B+1,+dest,+index,+source.Length+-+index+-+1);

++++return+dest;
}|code-block|syntax|javascript|1432378|它的用法如下：|1432379|class+Program
{
++++static+void+Main(string[]+args)
++++{
++++++++string[]+x+=+new+string[20];
++++++++for+(int+i+=+0;+i+<+x.Length;+i%2B%2B)
++++++++++++x[i]+=+(i%2B1).ToString();

++++++++string[]+y+=+(string[])MyArrayFunctions.RemoveAt(x,+3);

++++++++for+(int+i+=+0;+i+<+y.Length;+i%2B%2B)
++++++++++++Console.WriteLine(y[i]);
++++}
}|1432380|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/.NET_Framework^0|E|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Here is an old version I have that works on version 1.0 of the <a href="http://en.wikipedia.org/wiki/.NET_Framework" rel="nofollow noreferrer">.NET</a> framework and does not need generic types.

<pre><code>public static Array RemoveAt(Array source, int index)
{
 if (source == null)
 throw new ArgumentNullException("source");

 if (0 &gt; index || index &gt;= source.Length)
 throw new ArgumentOutOfRangeException("index", index, "index is outside the bounds of source array");

 Array dest = Array.CreateInstance(source.GetType().GetElementType(), source.Length - 1);
 Array.Copy(source, 0, dest, 0, index);
 Array.Copy(source, index + 1, dest, index, source.Length - index - 1);

 return dest;
}
</code></pre>

This is used like this:

<pre><code>class Program
{
 static void Main(string[] args)
 {
 string[] x = new string[20];
 for (int i = 0; i &lt; x.Length; i++)
 x[i] = (i+1).ToString();

 string[] y = (string[])MyArrayFunctions.RemoveAt(x, 3);

 for (int i = 0; i &lt; y.Length; i++)
 Console.WriteLine(y[i]);
 }
}
</code></pre>

blocks|key|1647414|text|这不完全是解决问题的方法，但是如果情况不重要，并且您很重视时间，那么您可以对可为Not的类型尝试这种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1647415|Foos[index]+=+null|code-block|syntax|javascript|1647416|然后检查您的逻辑中是否有空条目。|1647417|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Not exactly the way to go about this, but if the situation is trivial and you value your time, you can try this for nullable types. 

<pre><code>Foos[index] = null
</code></pre>

and later check for null entries in your logic..

blocks|key|1647520|text|像往常一样，我去派对迟到了.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1647521|我想在已经存在的很好的解决方案列表中添加另一个选项。=)|1647522|我认为这是一个很好的扩展机会。|1647523|参考：http://msdn.microsoft.com/en-us/library/bb311042.aspx|offset|length|1647524|因此，我们定义了一些静态类，并在其中定义了我们的方法。|1647525|在那之后，我们可以随意使用我们的扩展方法。=)|1647526|using+System;

namespace+FunctionTesting+{

++++//+The+class+doesn't+matter,+as+long+as+it's+static
++++public+static+class+SomeRandomClassWhoseNameDoesntMatter+{

++++++++//+Here's+the+actual+method+that+extends+arrays
++++++++public+static+T[]+RemoveAt<T>(+this+T[]+oArray,+int+idx+)+{
++++++++++++T[]+nArray+=+new+T[oArray.Length+-+1];
++++++++++++for(+int+i+=+0;+i+<+nArray.Length;+%2B%2Bi+)+{
++++++++++++++++nArray[i]+=+(+i+<+idx+)+?+oArray[i]+:+oArray[i+%2B+1];
++++++++++++}
++++++++++++return+nArray;
++++++++}
++++}

++++//+Sample+usage...
++++class+Program+{
++++++++static+void+Main(+string[]+args+)+{
++++++++++++string[]+myStrArray+=+{+"Zero",+"One",+"Two",+"Three"+};
++++++++++++Console.WriteLine(+String.Join(+"+",+myStrArray+)+);
++++++++++++myStrArray+=+myStrArray.RemoveAt(+2+);
++++++++++++Console.WriteLine(+String.Join(+"+",+myStrArray+)+);
++++++++++++/*+Output
+++++++++++++*+"Zero+One+Two+Three"
+++++++++++++*+"Zero+One+Three"
+++++++++++++*/

++++++++++++int[]+myIntArray+=+{+0,+1,+2,+3+};
++++++++++++Console.WriteLine(+String.Join(+"+",+myIntArray+)+);
++++++++++++myIntArray+=+myIntArray.RemoveAt(+2+);
++++++++++++Console.WriteLine(+String.Join(+"+",+myIntArray+)+);
++++++++++++/*+Output
+++++++++++++*+"0+1+2+3"
+++++++++++++*+"0+1+3"
+++++++++++++*/
++++++++}
++++}
}|code-block|syntax|javascript|1647527|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb311042.aspx^0|0|0|0|3|1H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@$H|14|I|15|1|16]]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|19|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

As usual, I'm late to the party... 

I'd like to add another option to the nice solutions list already present. =) 
I would see this as a good opportunity for Extensions. 

Reference:
<a href="http://msdn.microsoft.com/en-us/library/bb311042.aspx" rel="nofollow">http://msdn.microsoft.com/en-us/library/bb311042.aspx</a>
 

So, we define some static class and in it, our Method. 
After that, we can use our extended method willy-nilly. =)

<pre><code>using System;

namespace FunctionTesting {

 // The class doesn't matter, as long as it's static
 public static class SomeRandomClassWhoseNameDoesntMatter {

 // Here's the actual method that extends arrays
 public static T[] RemoveAt&lt;T&gt;( this T[] oArray, int idx ) {
 T[] nArray = new T[oArray.Length - 1];
 for( int i = 0; i &lt; nArray.Length; ++i ) {
 nArray[i] = ( i &lt; idx ) ? oArray[i] : oArray[i + 1];
 }
 return nArray;
 }
 }

 // Sample usage...
 class Program {
 static void Main( string[] args ) {
 string[] myStrArray = { "Zero", "One", "Two", "Three" };
 Console.WriteLine( String.Join( " ", myStrArray ) );
 myStrArray = myStrArray.RemoveAt( 2 );
 Console.WriteLine( String.Join( " ", myStrArray ) );
 /* Output
 * "Zero One Two Three"
 * "Zero One Three"
 */

 int[] myIntArray = { 0, 1, 2, 3 };
 Console.WriteLine( String.Join( " ", myIntArray ) );
 myIntArray = myIntArray.RemoveAt( 2 );
 Console.WriteLine( String.Join( " ", myIntArray ) );
 /* Output
 * "0 1 2 3"
 * "0 1 3"
 */
 }
 }
}
</code></pre>

blocks|key|1432733|text|试试下面的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1432734|myArray+=+myArray.Where(s+=>+(myArray.IndexOf(s)+!=+indexValue)).ToArray();|code-block|syntax|javascript|1432735|或|1432736|myArray+=+myArray.Where(s+=>+(s+!=+"not_this")).ToArray();|1432737|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Try below code:

<pre><code>myArray = myArray.Where(s =&gt; (myArray.IndexOf(s) != indexValue)).ToArray();
</code></pre>

or

<pre><code>myArray = myArray.Where(s =&gt; (s != "not_this")).ToArray();
</code></pre>

blocks|key|1647139|text|我是这么做的.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1647140|++++public+static+ElementDefinitionImpl[]+RemoveElementDefAt(
++++++++ElementDefinition[]+oldList,
++++++++int+removeIndex
++++)
++++{
++++++++ElementDefinitionImpl[]+newElementDefList+=+new+ElementDefinitionImpl[+oldList.Length+-+1+];

++++++++int+offset+=+0;
++++++++for+(+int+index+=+0;+index+<+oldList.Length;+index%2B%2B+)
++++++++{
++++++++++++ElementDefinitionImpl+elementDef+=+oldList[+index+]+as+ElementDefinitionImpl;
++++++++++++if+(+index+==+removeIndex+)
++++++++++++{
++++++++++++++++//++This+is+the+one+we+want+to+remove,+so+we+won't+copy+it.++But+
++++++++++++++++//++every+subsequent+elementDef+will+by+shifted+down+by+one.
++++++++++++++++offset+=+-1;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++newElementDefList[+index+%2B+offset+]+=+elementDef;
++++++++++++}
++++++++}
++++++++return+newElementDefList;
++++}|code-block|syntax|javascript|1647141|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's how I did it...

<pre><code> public static ElementDefinitionImpl[] RemoveElementDefAt(
 ElementDefinition[] oldList,
 int removeIndex
 )
 {
 ElementDefinitionImpl[] newElementDefList = new ElementDefinitionImpl[ oldList.Length - 1 ];

 int offset = 0;
 for ( int index = 0; index &lt; oldList.Length; index++ )
 {
 ElementDefinitionImpl elementDef = oldList[ index ] as ElementDefinitionImpl;
 if ( index == removeIndex )
 {
 // This is the one we want to remove, so we won't copy it. But 
 // every subsequent elementDef will by shifted down by one.
 offset = -1;
 }
 else
 {
 newElementDefList[ index + offset ] = elementDef;
 }
 }
 return newElementDefList;
 }
</code></pre>

blocks|key|1432290|text|在一个普通的数组中，你必须向下移动超过2的所有数组条目，然后使用resize方法调整它的大小。使用ArrayList可能会更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1432291|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In a normal array you have to shuffle down all the array entries above 2 and then resize it using the Resize method. You might be better off using an ArrayList.

blocks|key|1432659|text|++++private+int[]+removeFromArray(int[]+array,+int+id)
++++{
++++++++int+difference+=+0,+currentValue=0;
++++++++//get+new+Array+length
++++++++for+(int+i=0;+i<array.Length;+i%2B%2B)
++++++++{
++++++++++++if+(array[i]==id)
++++++++++++{
++++++++++++++++difference+%2B=+1;
++++++++++++}
++++++++}
++++++++//create+new+array
++++++++int[]+newArray+=+new+int[array.Length-difference];
++++++++for+(int+i+=+0;+i+<+array.Length;+i%2B%2B+)
++++++++{
++++++++++++if+(array[i]+!=+id)
++++++++++++{
++++++++++++++++newArray[currentValue]+=+array[i];
++++++++++++++++currentValue+%2B=+1;
++++++++++++}
++++++++}

++++++++return+newArray;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1432660|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> private int[] removeFromArray(int[] array, int id)
 {
 int difference = 0, currentValue=0;
 //get new Array length
 for (int i=0; i&lt;array.Length; i++)
 {
 if (array[i]==id)
 {
 difference += 1;
 }
 }
 //create new array
 int[] newArray = new int[array.Length-difference];
 for (int i = 0; i &lt; array.Length; i++ )
 {
 if (array[i] != id)
 {
 newArray[currentValue] = array[i];
 currentValue += 1;
 }
 }

 return newArray;
 }
</code></pre>

blocks|key|1432706|text|这是我根据一些现有答案生成的辅助方法的一个小集合。它使用扩展和带有引用参数的静态方法来实现最大的理想性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1432707|public+static+class+Arr
{
++++public+static+int+IndexOf<TElement>(this+TElement[]+Source,+TElement+Element)
++++{
++++++++for+(var+i+=+0;+i+<+Source.Length;+i%2B%2B)
++++++++{
++++++++++++if+(Source[i].Equals(Element))
++++++++++++++++return+i;
++++++++}

++++++++return+-1;
++++}

++++public+static+TElement[]+Add<TElement>(ref+TElement[]+Source,+params+TElement[]+Elements)
++++{
++++++++var+OldLength+=+Source.Length;
++++++++Array.Resize(ref+Source,+OldLength+%2B+Elements.Length);

++++++++for+(int+j+=+0,+Count+=+Elements.Length;+j+<+Count;+j%2B%2B)
++++++++++++Source[OldLength+%2B+j]+=+Elements[j];

++++++++return+Source;
++++}

++++public+static+TElement[]+New<TElement>(params+TElement[]+Elements)
++++{
++++++++return+Elements+??+new+TElement[0];
++++}

++++public+static+void+Remove<TElement>(ref+TElement[]+Source,+params+TElement[]+Elements)
++++{
++++++++foreach+(var+i+in+Elements)
++++++++++++RemoveAt(ref+Source,+Source.IndexOf(i));
++++}

++++public+static+void+RemoveAt<TElement>(ref+TElement[]+Source,+int+Index)
++++{
++++++++var+Result+=+new+TElement[Source.Length+-+1];

++++++++if+(Index+>+0)
++++++++++++Array.Copy(Source,+0,+Result,+0,+Index);

++++++++if+(Index+<+Source.Length+-+1)
++++++++++++Array.Copy(Source,+Index+%2B+1,+Result,+Index,+Source.Length+-+Index+-+1);

++++++++Source+=+Result;
++++}
}|code-block|syntax|javascript|1432708|在性能方面，它是不错的，但它可能还可以改进。Remove依赖于IndexOf，并通过调用RemoveAt为每个要删除的元素创建一个新数组。|offset|length|style|CODE|1432709|IndexOf是唯一的扩展方法，因为它不需要返回原始数组。New接受某些类型的多个元素以生成所述类型的新数组。所有其他方法都必须接受原始数组作为引用，因此不需要在以后赋值结果，因为这已经在内部发生了。|1432710|我会定义一个用于合并两个数组的Merge方法；但是，使用Add方法已经可以通过传入一个实际的数组而不是多个单独的元素来实现这一点。因此，可以通过以下两种方式使用Add来连接两组元素：|1432711|Arr.Add<string>(ref+myArray,+"A",+"B",+"C");|1432712|或|1432713|Arr.Add<string>(ref+myArray,+anotherArray);|1432714|entityMap^0|0|0|M|6|V|7|18|8|0|0|7|T|3|0|F|5|S|3|28|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@$I|18|J|19|K|L]|$I|1A|J|1B|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|X|$]]

Here's a small collection of helper methods I produced based on some of the existing answers. It utilizes both extensions and static methods with reference parameters for maximum idealness:

<pre><code>public static class Arr
{
 public static int IndexOf&lt;TElement&gt;(this TElement[] Source, TElement Element)
 {
 for (var i = 0; i &lt; Source.Length; i++)
 {
 if (Source[i].Equals(Element))
 return i;
 }

 return -1;
 }

 public static TElement[] Add&lt;TElement&gt;(ref TElement[] Source, params TElement[] Elements)
 {
 var OldLength = Source.Length;
 Array.Resize(ref Source, OldLength + Elements.Length);

 for (int j = 0, Count = Elements.Length; j &lt; Count; j++)
 Source[OldLength + j] = Elements[j];

 return Source;
 }

 public static TElement[] New&lt;TElement&gt;(params TElement[] Elements)
 {
 return Elements ?? new TElement[0];
 }

 public static void Remove&lt;TElement&gt;(ref TElement[] Source, params TElement[] Elements)
 {
 foreach (var i in Elements)
 RemoveAt(ref Source, Source.IndexOf(i));
 }

 public static void RemoveAt&lt;TElement&gt;(ref TElement[] Source, int Index)
 {
 var Result = new TElement[Source.Length - 1];

 if (Index &gt; 0)
 Array.Copy(Source, 0, Result, 0, Index);

 if (Index &lt; Source.Length - 1)
 Array.Copy(Source, Index + 1, Result, Index, Source.Length - Index - 1);

 Source = Result;
 }
}
</code></pre>

Performance wise, it is decent, but it could probably be improved. <code>Remove</code> relies on <code>IndexOf</code> and a new array is created for each element you wish to remove by calling <code>RemoveAt</code>.

<code>IndexOf</code> is the only extension method as it does not need to return the original array. <code>New</code> accepts multiple elements of some type to produce a new array of said type. All other methods must accept the original array as a reference so there is no need to assign the result afterward as that happens internally already.

I would've defined a <code>Merge</code> method for merging two arrays; however, that can already be accomplished with <code>Add</code> method by passing in an actual array versus multiple, individual elements. Therefore, <code>Add</code> may be used in the following two ways to join two sets of elements:

<pre><code>Arr.Add&lt;string&gt;(ref myArray, "A", "B", "C");
</code></pre>

Or 

<pre><code>Arr.Add&lt;string&gt;(ref myArray, anotherArray);
</code></pre>

I have an array of Foo objects. How do I remove the second element of the array?

I need something similar to <code>RemoveAt()</code> but for a regular array.

Remove element of a regular array

我有一个Foo对象数组。如何删除数组的第二个元素？我需要一些类似于RemoveAt()的东西，但是需要一个常规的数组。

问删除正则数组的元素
EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问删除正则数组的元素EN

回答 13

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问删除正则数组的元素
EN