Supprimer un élément d'un tableau régulier

Question

J'ai un tableau d'objets Foo. Comment puis-je supprimer le deuxième élément du tableau?

J'ai besoin de quelque chose de similaire à RemoveAt() mais pour un tableau régulier.

Answer 1

Si vous ne voulez pas utiliser List:

 var foos = new List<Foo>(array);
foos.RemoveAt(index);
return foos.ToArray();
 

Vous pouvez essayer cette méthode d'extension que je n'ai pas encore testée:

 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 + 1, dest, index, source.Length - index - 1);

    return dest;
}
 

Et utilisez-le comme:

 Foo[] bar = GetFoos();
bar = bar.RemoveAt(2);
 

Answer 2

La nature des tableaux est que leur longueur est immuable. Vous ne pouvez ajouter ou supprimer aucun des éléments du tableau.

Vous devrez créer un nouveau tableau d'un élément plus court et copier les anciens éléments dans le nouveau tableau, à l'exclusion de l'élément que vous souhaitez supprimer.

Il est donc probablement préférable d’utiliser une liste plutôt qu’un tableau.

Answer 3

J'utilise cette méthode pour supprimer un élément d'un tableau d'objets. Dans ma situation, mes tableaux sont de petite taille. Donc, si vous avez de grandes baies, vous aurez peut-être besoin d'une autre solution.

 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++;
        }

        i++;
    }

    return newIndicesArray;
}
 

Answer 4

C'est une façon de supprimer un élément de tableau, à partir de .Net 3.5, sans copier dans un autre tableau - en utilisant la même instance de tableau avec Array.Resize<T> :

 public static void RemoveAt<T>(ref T[] arr, int index)
{
    for (int a = index; a < 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);
}
 

Answer 5

Voici une ancienne version que j'ai qui fonctionne sur la version 1.0 du framework .NET et ne nécessite pas de types génériques.

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

    if (0 > index || 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 + 1, dest, index, source.Length - index - 1);

    return dest;
}
 

Ceci est utilisé comme ceci:

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

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

        for (int i = 0; i < y.Length; i++)
            Console.WriteLine(y[i]);
    }
}