Welcome to the Lounge

static void Filter(List<Foo> list)
{
    Queue<Foo> queue = new Queue<Foo>(list);
    list.Clear();
    Foo item = null;
    while (item = queue.Dequeue())
    {
        if (!Remove(item))
            list.Add(item);
    }
}

static void Filter(List<Foo> list) =>
    list.RemoveAll(item => IsRemovable(item)); //I agree with Dave on IsRemovable over Remove.

Jon McKee wrote:

There's no point in involving a Queue in the first place

F-ES Sitecore wrote:

In the original code a List was used to process something that isn't best represented as a List, it was data used as a stack or a queue so using Queue makes that explicit.

F-ES Sitecore wrote:

Also I don't think accessing the last item of a List using an index is very efficient.

Jon McKee wrote:

We don't really know this. All the function represents is a filter operation. The main purpose of the List outside of this function could require random access

Jon McKee wrote:

Numerical indexing is O(1) for array-based List access since underneath everything it's just pointer arithmetic.

static void FilterList(ref List<foo> list)
   {
   list = list.RemoveAll(f => Remove(f)).ToList();
   }

static IEnumerable<Foo> FilterList(List<Foo> list)
   {
   return list.RemoveAll(f => Remove(f));
   }

static void FilterList(List<Foo> list)
   {
   list.RemoveAll(f => Remove(f));
   }

static void FilterList(List<Foo> list)
  => list.RemoveAll(Remove);

// This method removes all items which matches the predicate.
        // The complexity is O(n).   
        public int RemoveAll(Predicate<T> match) {
            if( match == null) {
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
            }
            Contract.Ensures(Contract.Result<int>() >= 0);
            Contract.Ensures(Contract.Result<int>() <= Contract.OldValue(Count));
            Contract.EndContractBlock();
    
            int freeIndex = 0;   // the first free slot in items array
 
            // Find the first item which needs to be removed.
            while( freeIndex < _size && !match(_items[freeIndex])) freeIndex++;            
            if( freeIndex >= _size) return 0;
            
            int current = freeIndex + 1;
            while( current < _size) {
                // Find the first item which needs to be kept.
                while( current < _size && match(_items[current])) current++;            
 
                if( current < _size) {
                    // copy item to the free slot.
                    _items[freeIndex++] = _items[current++];
                }
            }                       
            
            Array.Clear(_items, freeIndex, _size - freeIndex);
            int result = _size - freeIndex;
            _size = freeIndex;
            _version++;
            return result;
        }