如何从开始到特定条件从通用列表中删除项目

Question

I have a generic list such as below,

var steps = new List<Step> 
{
    new Step { From = "A", To = "D", Quantity = 0 }, 
    new Step { From = "D", To = "J", Quantity = 0 }, 
    new Step { From = "J", To = "T", Quantity = 0 },
    new Step { From = "D", To = "K", Quantity = 0 }, 
    new Step { From = "K", To = "T", Quantity = 0 },
    new Step { From = "E", To = "K", Quantity = 0 },
    new Step { From = "A", To = "E", Quantity = 0 },
    new Step { From = "B", To = "E", Quantity = 0 },
    new Step { From = "E", To = "L", Quantity = 5 },
    new Step { From = "B", To = "F", Quantity = 5 },
    new Step { From = "B", To = "G", Quantity = 5 },
    new Step { From = "F", To = "I", Quantity = 5 },
    new Step { From = "G", To = "I", Quantity = 5 },
    new Step { From = "C", To = "H", Quantity = 0 },
    new Step { From = "H", To = "Z", Quantity = 0 },
    new Step { From = "H", To = "Y", Quantity = 0 },
    new Step { From = "H", To = "X", Quantity = 5 },
    new Step { From = "X", To = "I", Quantity = 5 },
    new Step { From = "I", To = "V", Quantity = 5 },
    new Step { From = "L", To = "V", Quantity = 5 },
    new Step { From = "Y", To = "V", Quantity = 5 },
    new Step { From = "Y", To = "M", Quantity = 0 },
    new Step { From = "Z", To = "M", Quantity = 0 },
    new Step { From = "Z", To = "N", Quantity = 0 },
    new Step { From = "M", To = "O", Quantity = 0 },
};

I would like to remove items from the list. It will start first item of the list. It will remove items until next quantity of item is greater then zero. It should do the same job reverse.

It is like string.Trim('0') .

My result should be like below :

var steps = new List<Step> 
{
    new Step { From = "E", To = "L", Quantity = 5 },
    new Step { From = "B", To = "F", Quantity = 5 },
    new Step { From = "B", To = "G", Quantity = 5 },
    new Step { From = "F", To = "I", Quantity = 5 },
    new Step { From = "G", To = "I", Quantity = 5 },
    new Step { From = "C", To = "H", Quantity = 0 },
    new Step { From = "H", To = "Z", Quantity = 0 },
    new Step { From = "H", To = "Y", Quantity = 0 },
    new Step { From = "H", To = "X", Quantity = 5 },
    new Step { From = "X", To = "I", Quantity = 5 },
    new Step { From = "I", To = "V", Quantity = 5 },
    new Step { From = "L", To = "V", Quantity = 5 },
    new Step { From = "Y", To = "V", Quantity = 5 },
};

Answer 1

You want something like this:

steps = steps.SkipWhile(s => s.Quantity == 0).Reverse()
             .SkipWhile(s => s.Quantity == 0).Reverse()
             .ToList();

This would be the "simple" solution I guess. It would be faster to search for the bounds of the desired range of steps first and then get that using GetRange .

Answer 2

I think, the best option is reassign step to new list

list = list.SkipWhile(s => s.Quantity == 0).ToList();

UPD : Yeah, my fault, I made TrimStart only. Was inattention.

Answer 3

This should do the trick:

steps = steps
    .SkipWhile(step => step.Quantity == 0)
    .TakeWhile((step, index) =>
        steps.Skip(index).Any(nextSteps => nextSteps.Quantity != 0))
    .ToList();

The SkipWhile first skips all steps with quantity=0, then it takes all steps so long as there are following steps with a quantity != 0.

Answer 4

Whilst the simple solution would be to revere the list twice that could get expensive for large lists.

list = list.SkipWhile(s => s.Quantity == 0).Reverse()
              .SkipWhile( s => s.Quantity == 0).Reverse().ToList();

A more efficient solution would be to define an extension method like this:

public static IEnumerable TrimLast(IEnumerable<T> this, Func<T, Bool> cond) {
    foreach (var item in this) {
       if (!cond(item)) {
           foreach (var storeditem in store) {
               yield return storeditem;
           }
           store.Clear;
           yield return item;
       } else {
           store.Add(item);
       }
    }
}

then call it: list = list.SkipWhile(s => s.Quantity == 0).TrimLast(s => s.Quantity == 0).ToList(); This has the advantage of never storing more than the longest consecutive sequence of zeros unlike the reverse solution which needs to store the whole list twice.