Click here to Skip to main content
12,400,183 members (55,461 online)
Click here to Skip to main content
Add your own
alternative version

Stats

28.2K views
12 bookmarked
Posted

Useful Generic Array Functions

, 10 Apr 2008 CPOL
Rate this:
Please Sign up or sign in to vote.
Useful Generic Array Functions used to append, resize, remove elements in an array

Introduction

The standard .NET Framework offers quite a few generic functions to manipulate arrays, however there are some functionalities where extra code will be needed such as appending to the array, removing an element from the array, or removing all elements that fall under a condition.

Background

You should have some basic knowledge of generic classes, lists, arrays, etc.

The Array object contains some useful generic functionalities such as:

  • ConvertAll<T,O>
  • Exists<T>
  • Find<T>
  • Resize<T>
  • TrueForAll<T>

However, these functionalities by themselves sometimes do not get the job done. This is why I've extended the functionalities a bit more.

Using the Code

Basically the code is very simple and gets the job done.

 class ArrayEx {
    /// <span class="code-SummaryComment"><summary></span>
    /// Appends a list of elements to the end of an array
    /// <span class="code-SummaryComment"></summary></span>
    /// <span class="code-SummaryComment"><typeparam name="T"></typeparam></span>
    /// <span class="code-SummaryComment"><param name="array"></param></span>
    /// <span class="code-SummaryComment"><param name="items"></param></span>
    public static void Append<T>(ref T[] array, params T[] items)
    {
        int oldLength = array.Length;
        //make room for new items
        Array.Resize<T>(ref array, oldLength + items.Length);
        
        for(int i=0;i<items.Length;i++)
            array[oldLength + i] = items[i];
    }

    /// <span class="code-SummaryComment"><summary></span>
    /// Remove an Array at a specific Location
    /// <span class="code-SummaryComment"></summary></span>
    /// <span class="code-SummaryComment"><typeparam name="T"></typeparam></span>
    /// <span class="code-SummaryComment"><param name="index">index to remove at</param></span>
    /// <span class="code-SummaryComment"><param name="list">The Array Object</param></span>
    public static void RemoveAt<T>(int index, ref T[] list)
    {
        //pre:
        if (index < 0 || list == null | list.Length == 0) return;

        //move everything from the index on to the left one then remove last empty
        if (list.Length > index + 1)
            for (int i = index + 1; i < list.Length; i++)
                list[i - 1] = list[i]; 

        Array.Resize<T>(ref list, list.Length - 1);
    }

    /// 
    ///<span class="code-SummaryComment"><summary> Thanks to homer.</span>
    /// Remove all elements in an array satisfying a predicate
    /// <span class="code-SummaryComment"></summary></span>
    /// <span class="code-SummaryComment"><typeparam name="T"></typeparam></span>
    /// <span class="code-SummaryComment"><param name="list">The Array Object</param></span>
    /// <span class="code-SummaryComment"><param name="condition">A Predicate when the element shall get removed under.</span>
    /// <span class="code-SummaryComment"></param></span>
    /// <span class="code-SummaryComment"><returns>Number of elements removed</returns></span>
    public static int RemoveAll<T>(ref T[] list, Predicate<T> condition)
    {
    if (null == condition || null == list || 0 == list.Length) return 0;
    
    int length = list.Length;
    int destinationIndex = 0;
    T[] destinationArray = new T[length];
    
    for (int i = 0; i < list.Length; i++)
    {
        if (!condition(list[i]))
        {
            destinationArray[destinationIndex] = list[i];
            destinationIndex++;
        }
    }
    
    if (destinationIndex != length)
    {
        Array.Resize<T>(ref destinationArray, destinationIndex);
        list = destinationArray;
    }
    
    return length - destinationIndex;
    }
}

First We Have Append<T>

public static void Append<T>(ref T[] array, params T[] items) 

This function takes any array and appends more elements at the end of the array keeping the size of the array equal to the number of elements.

Keep in mind that you do not want to be doing this over and over again since every append will cost performance. However, if utilized correctly, meaning the items being appended only happens at the end of an operation, then this will be fine.

Using The Method...

string[] strArray = new string[] { "a", "b", "c" };
string[] strArray2 = new string[] { "d", "e", "f" };

// appends d e f to the first array
ArrayEx.Append<string>(ref strArray, strArray2);

// appends one more element
ArrayEx.Append<string>(ref strArray, "g");

Console.Out.Write(string.Join(strArray));  

Then We Have RemoveAt<T>

public static void RemoveAt<T>(int index, ref T[] list) 

This method will remove an element at a specific location like the IList.RemoveAt and return the element removed.

Using The Method...

string[] strArray = new string[] { "a", "b", "c" };       
// remove element b
string Element = ArrayEx.RemoveAt<string>(1,ref strArray);

Then We Have RemoveAll<T>

public static int RemoveAll<T>(ref T[] list, Predicate<T> condition) 

This method will remove all elements from an Array satisfying a conditional predicate.

The function also returns the number of elements removed. You can alter the function to create all the elements removed if you wish. This can then be used in a recursive search to reduce search surface space.

Using The Method...

// create array from sentence
string[] strArray = "My Name is Yang Yu and I'm the best!".Split(' ');

int RemoveCount = Ordering.RemoveAll<string>(ref strArray, new Predicate<string>(
            delegate(string element)
{
    // remove all elements with ' in them
    return element.Contains("'");
}
));

Points of Interest

You may also want to create an InsertAt<T>, or Merge<T>, etc.

The functionalities provided here do not replace the ones in the wrapper class List<T> which does contain most of these methods. Determining when to use Array and when to use List depends on a number of variables. Beware...

History

  • 11th April, 2008 - Article created

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Yang Yu
Architect
Canada Canada
Engineer, maker, food lover

You may also be interested in...

Comments and Discussions

 
GeneralMy vote of 2 Pin
Andrey Chuvahin29-Sep-09 2:32
memberAndrey Chuvahin29-Sep-09 2:32 
GeneralMy vote of 1 Pin
pooya_p31-Jul-09 6:24
memberpooya_p31-Jul-09 6:24 
GeneralRemoveAll Pin
Richard Deeming14-Apr-08 7:41
memberRichard Deeming14-Apr-08 7:41 
GeneralRe: RemoveAll Pin
yang yu 179999915-Apr-08 7:45
memberyang yu 179999915-Apr-08 7:45 
GeneralNeedless Pin
PIEBALDconsult11-Apr-08 3:32
memberPIEBALDconsult11-Apr-08 3:32 
GeneralExtesion Methods Pin
Vivek Ragunathan11-Apr-08 3:20
memberVivek Ragunathan11-Apr-08 3:20 
GeneralSource Pin
Bill Warner11-Apr-08 2:05
memberBill Warner11-Apr-08 2:05 
GeneralNo source code Pin
leppie 10-Apr-08 23:31
member leppie 10-Apr-08 23:31 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.160721.1 | Last Updated 11 Apr 2008
Article Copyright 2008 by Yang Yu
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid