Remove objects of some kind of type from a List<T> in C# using extension methods?

Question

I wonder if its possible to remove all the objects from the same kind from a generic List using extension methods. something like this code:

public static Remove<T>(this List<[any type]> list)
{
    // some code to remove the objects of type T from the list
}

I can do this by using the following code:

public static Remove<T, K>(this List<K> list)
{
    // some code to remove the objects of type T from the List<K>
}

but I want to just use on type (T), without need to specify any type K. by doing that the user can use this extension method by simply write this:

List<object> list = new List<object>();
list.Add(1);
list.Add("text");

// remove all int type objects from the list
list.Remove<int>();

a extension method which I can use to do something exactly like the above code is what I really need here.

best regards

Answer 1

What you're trying to do is have type inference work on one type parameter, but specify the other explicitly. I'm afraid C# doesn't allow that.

The form using the non-generic IList given by Justin will work because it only has the one type parameter (the type of element to remove). It's pretty ugly though.

Is this something you actually need often enough that you're bothered about specifying both type arguments?

Answer 2

Do you need to provide the filter type as a generic?

public static IEnumerable<T> Remove<T>(this IEnumerable<T> items, 
                                            Type removeThese)
{
    return items.Where(i => !removeThese.IsInstanceOfType(i));
}

// usage
var newSet = mylist.Remove(typeof(int));

Answer 3

Not sure if this will work or not...but it's worth a shot (I can't compile to double check):

public static void Remove<T>(this IList list)
{
    if(list != null)
    {
        var toRemove = list.OfType<T>().ToList();

        foreach(var item in toRemove)
            list.Remove(item);
    }
}

Or if you need something a little more strict (rather than any object that can be cast to the type), you could try:

public static void Remove<T>(this IList list)
{
    if(list != null)
    {
        var toRemove = list.Where(i => typeof(i) == typeof(T)).ToList();

        foreach(var item in toRemove)
            list.Remove(item);
    }
}

In theory, you should be good to go. List<T> implements IList which implements IEnumerable. IList provides Remove() and IEnumerable provides the extension method.

Be aware that this could most definitely produce unexpected results depending on the types in the collection. I agree with Jon Skeet...it's most definitely ugly.

Answer 4

I don't recommend this, as it seems like an API which will be very difficult to understand and maintain.

That being said, the following should work:

public static void Remove<T>(this IList list)
{
     Type type = typeof(T);
     var itemsToRemove = list.Cast<object>.Where(o => o.GetType() == type).ToList();
     foreach(var item in itemsToRemove)
     {
          list.Remove(item);
     }
}

Answer 5

What you really want to do is have an extension method like so:

public static void Remove<T>(this IList list)
{
    // Cycle through everything, comparing the types.
    for (int index = list.Count; index >= 0; --index)
    {
        // Get the object.
        object item = list[index];

        // If the item is null, continue.
        if (item == null) continue;

        // Remove the item if the types match.
        if (typeof(T) == item.GetType()) list.RemoveAt(index);
    } 
}

Note that you can only use this for List<T>, since it implements the non-generic IList interface. The IList<T> interface does not derive from the non-generic IList interface.

Answer 6

Here is yet another variant. Return only used in case you want to chain the method.

public static List<TList> Remove<TList, TRemove>(this List<TList> list)
{
    list.RemoveAll(item => item is TRemove);
    return list;
}

Answer 7

thanks to the greate answer of Justin Niessner I managed to do it by using the following code:

public static void Remove<T>(this IList list)
{
    ArrayList deleteList = new ArrayList();

    foreach (var item in list)
        if (item.GetType() == typeof(T))
            deleteList.Add(item);

    for (int i = 0; i < deleteList.Count; i++)
        list.Remove(deleteList[i]);        
}

in the Justin Niessner answer there is one problem. you can not delete an enumarator item in foreach block.

Answer 8

I would probably do something like:

enumerable.Cast<object>().Where(o => !(o is T))

And skip the fact that enumerable is a list. (Cast here is being used to ensure that Where works, if you already have a generic enumerable then you can skip it)

Answer 9

Step backwards through the list and remove the ones that match the undesired type.

public static void RemoveAllOfType<T>( this IList list )
{
    for( int index = list.Count - 1; index >= 0; index -- )
    {
        if( list[index] is T )
        {
            list.RemoveAt( index );
        }
    }
}

If you are always going to be using List<object> you can simplify things a little more.

public static void RemoveAllOfType<T>( this List<object> list )
{
    list.RemoveAll( item => item is T );
}

Happy Coding!

Answer 10

Not sure if this will do

static class test
    {
        public static void RemAll<T>(this List<Object> self, T t) where T : Type
        {
            self.RemoveAll(x => x.GetType()==t);
        }
    }

Can be invoked as below

  static void Main(string[] args)
        {
            List<object> ll = new List<object>() { 1, 2, "abcd", "xyz", 22.3, 900, "junk" };
            ll.RemAll(typeof(int));
            ll.ForEach(x => Console.WriteLine(x));
        }