var segments = sr.WorkingSegments.Cast<ServiceSegment>().Concat(sr.ProtectionSegments.Cast<ServiceSegment>());
var connections = from s in segments
                  from p in s.SegmentParcels.Cast<SegmentParcel>
                  let nc = p.NetworkConnection
                  where nc != null
                  select nc;
foreach(var connection in connections)
    Collect(connection, protection);

    private void Collect(IService sr, ObjectCategories protection)
    {
      foreach (NetworkConnection networkConnection in GetServiceConnections(sr))
        Collect(networkConnection, protection);
    }

    private IEnumerable<NetworkConnection> GetServiceConnections(IService service)
    {
      List<NetworkConnection> networkConnections = new List<NetworkConnection>();

      foreach (ServiceSegment segment in GetServiceSegments(service))
        foreach (NetworkConnection networkConnection in GetSegmentConnections(segment))
          networkConnections.Add(networkConnection);

      return networkConnections;
    }

    private IEnumerable<ServiceSegment> GetServiceSegments(IService service)
    {
      List<ServiceSegment> segments = new List<ServiceSegment>();

      foreach (ServiceSegment item in service.WorkingSegments)
        segments.Add(item);
      foreach (ServiceSegment item in service.ProtectionSegments)
        segments.Add(item);

      return segments;
    }

    private IEnumerable<NetworkConnection> GetSegmentConnections(ServiceSegment segment)
    {
      List<NetworkConnection> networkConnections = new List<NetworkConnection>();

      foreach (SegmentParcel parcel in segment.SegmentParcels)
        if (parcel.NetworkConnection != null)
          networkConnections.Add(parcel.NetworkConnection);

      return networkConnections;
    }

    private void Collect(IService sr, ObjectCategories protection)
    {
      foreach (NetworkConnection networkConnection in GetServiceConnections(sr))
        Collect(networkConnection, protection);
    }

    private IEnumerable<ServiceSegment> GetServiceSegments(IService service)
    {
      return Enumerable.Concat(service.WorkingSegments, service.ProtectionSegments);
    }

    private IEnumerable<NetworkConnection> GetServiceConnections(IService service)
    {
      return GetServiceSegments(service).SelectMany(s => GetSegmentConnections(s));
    }

    private IEnumerable<NetworkConnection> GetSegmentConnections(ServiceSegment segment)
    {
      return segment.SegmentParcels.Select(s => s.NetworkConnection).Where(s => s != null);
    }

return items.FirstOrDefault(item => criteria.All(spec => spec.IsMetBy(item)));

public class Pos
{
    public double X { get; set; }
    public double Y { get; set; }
}

public class TrackItem
{
    public Pos Pos { get; set; }
    public DateTime Time { get; set; }
}

public enum StationPassStatus
{
    InTime, Late, Early, NotPassed
}

public static class EnumeraleExtensions
{
    public static Tuple<IEnumerable<T>, IEnumerable<T>> Span<T>(this IEnumerable<T> seq, Func<T, bool> pred)
    {
        return Tuple.Create(seq.TakeWhile(pred), seq.SkipWhile(pred));
    }

    public static IEnumerable<S> Scan<T, S>(this IEnumerable<T> seq, S seed, Func<T, S, S> f)
    {
        var state = seed; //Вот тут происходит передача состояния
        foreach (var e in seq)
        {
            yield return state;
            state = f(e, state);
        }
    }
}

public static class TrackExtensions
{
    public static double Dist(Pos p1, Pos p2)
    {
        var x = p1.X - p2.X;
        var y = p1.Y - p2.Y;
        return Math.Sqrt(x * x - y * y);
    }

    public static Tuple<IEnumerable<TrackItem>, IEnumerable<TrackItem>> 
            GetTrackSegmentWithinRadius(this IEnumerable<TrackItem> track, Pos pos, double radius)
    {
        return track.SkipWhile(t => Dist(t.Pos, pos) > radius)
                    .Span(t => Dist(t.Pos, pos) <= radius);
    }

    public static StationPassStatus GetStationPassStatus
        (this IEnumerable<TrackItem> track, DateTime stationTime)
    {
        if (!track.Any())
        {
            return StationPassStatus.NotPassed;
        }
        else
        {
            var times = track.Select(t => t.Time);
            var min = times.Min();
            var max = times.Max();

            //Супер-логика
            return StationPassStatus.InTime; 
        }

    }
}

class Program
{
    static Pos[] stations = new Pos[] { ... };

    static IEnumerable<Tuple<int, StationPassStatus>> GetScheduleDiff
        (IEnumerable<Tuple<int,DateTime>> schedule, 
         IEnumerable<TrackItem> track,
         double radius)
    {
        return schedule.Scan(new { Track = track, StationId = 0,  Status = StationPassStatus.NotPassed}, 
                            (st, s) =>
                            {
                                var r = s.Track.GetTrackSegmentWithinRadius(stations[st.Item1], radius);
                                var status = r.Item1.GetStationPassStatus(st.Item2);
                                return new { Track = r.Item2, StationId = st.Item1, Status = status };
                            })
                        .Select(t => Tuple.Create(t.StationId, t.Status))
                        .Skip(1);
    }
}

L>Вот такой лучше:

L>var connections = from s in segments
L>                  from p in s.SegmentParcels.Cast<SegmentParcel>
L>                  let nc = p.NetworkConnection
L>                  where nc != null
L>                  select nc;
L>

var connections = from s in segments
                  from p in s.SegmentParcels.Cast<SegmentParcel>
                  where p.NetworkConnection != null
                  select p.NetworkConnection;

    private void Collect(IService sr, ObjectCategories protection)
    {
      IEnumerable<ServiceSegment> segments = _.Combine(sr.WorkingSegments, sr.ProtectionSegments);

      foreach (ServiceSegment segment in segments)
      {
        foreach (SegmentParcel parcel in segment.SegmentParcels)
        {
          if (parcel.NetworkConnection != null)
            Collect(parcel.NetworkConnection, protection);
        }
      }
    }

S_>public static T? FirstOrNull<T>(this IEnumerable<T> en) where T: struct
S_>{
S_>    return en.Count() > 0 ? (T?)en.First() : null;
S_>}
S_>

public static T FirstOrNull<T>(this IEnumerable<T> en) where T: class
{
}

I>>Не понял, на 20 строчек примитивного кода уже отладчик нужен ? ну и дела.

GetRouting(selection).DisposeAll();
...
if (GetRouting(selection).AtLeastOne())
            {
                context.CommandEnabled = true;
                return;
            }

sr.WorkingSegments.Cast<ServiceSegment>()
            .Concat(sr.ProtectionSegments.Cast<ServiceSegment>())
.SelectMany....

Enumerable.Concat(
   sr.WorkingSegments.Cast<ServiceSegment>(),
   sr.ProtectionSegments.Cast<ServiceSegment>()
)
.SelectMany...

S_>public static T? FirstOrNull<T>(this IEnumerable<T> en) where T: struct
S_>{
S_>    return en.Count() > 0 ? (T?)en.First() : null;
S_>}
S_>

public static bool TryFirst<T>(this IEnumerable<T> src, out T value) {
    try {
        value = src.First();
        return true;
    } catch (InvalidOperationException) {
        value = default(T);
        return false;
    }
}

foreach (T elem in src){
    value = elem;
    return true;
}
value = default(T);
return false;

      int certifiedStationIndex = -1;
      StationIntervalWithIndex unexpectedInterval = null;

      Dictionary<Tuple2<int, DateTime>, bool> undoneArrivalIntervals = new Dictionary<Tuple2<int, DateTime>, bool>();
      while (!isFinished)
      {
        while (rawArrivals.Count > 0 || rawDepartures.Count > 0)
        {
          JointIntervalData currentInterval = null;
          int currentStationIndex = -1;
          bool isArrivalInterval = CurrentPassingIsArrival(rawArrivals, rawDepartures);
          if (isArrivalInterval)
          {
            currentInterval = rawArrivals.Dequeue();
            currentStationIndex = FindStationIndex(result.StationPassings, certifiedStationIndex,
              currentInterval.Joint.Id, true, currentInterval.BeginTime, limitDelay);
            if (currentStationIndex == -1)
              continue;
            undoneArrivalIntervals[_.Tuple(currentInterval.Joint.Id, currentInterval.BeginTime)] = true;
          }
          else
          {
            currentInterval = rawDepartures.Dequeue();
            if (undoneArrivalIntervals.Remove(_.Tuple(currentInterval.Joint.Id, currentInterval.BeginTime)))
              continue;
            currentStationIndex = FindStationIndex(result.StationPassings, certifiedStationIndex,
              currentInterval.Joint.Id, false, currentInterval.ConclusionTime.Value, limitDelay);
            if (currentStationIndex == -1)
              continue;
          }

          StationPassing currentStation = result.StationPassings[currentStationIndex];
          // транспорт движется запланировано
          {
            if (currentStationIndex == certifiedStationIndex + 1)
            {
              currentStation.Interval = currentInterval;
              certifiedStationIndex++;
              unexpectedInterval = null;
              if (certifiedStationIndex == result.StationPassings.Length - 1)
              {
                isFinished = true;
                break;
              }
              continue;
            }
          }
          ...
        }

        yield return status;
      }

    private void Collect(IService sr, ObjectCategories protection)
    {
            sr.WorkingSegments.Cast<ServiceSegment>()
            .Concat(sr.ProtectionSegments.Cast<ServiceSegment>())
            .SelectMany(s => s.SegmentParcels.Cast<SegmentParcel>())
            .Select(p => p.NetworkConnection)
            .Where(nc => (nc != null))
            .Execute(nc => Collect(nc, protection));
     }

    private void Collect(IService sr, ObjectCategories protection)
    {
      List<ServiceSegment> segments = new List<ServiceSegment>();

      foreach (ServiceSegment item in sr.WorkingSegments)
        segments.Add(item);
      foreach (ServiceSegment item in sr.ProtectionSegments)
        segments.Add(item);

      foreach (ServiceSegment segment in segments)
      {
        foreach (SegmentParcel parcel in segment.SegmentParcels)
        {
          if (parcel.NetworkConnection == null)
            continue;

          Collect(parcel.NetworkConnection, protection);
        }
      }
    }

I>    private void Collect(IService sr, ObjectCategories protection)
I>    {
I>            sr.WorkingSegments.Cast<ServiceSegment>()
I>            .Concat(sr.ProtectionSegments.Cast<ServiceSegment>())
I>            .SelectMany(s => s.SegmentParcels.Cast<SegmentParcel>())
I>            .Select(p => p.NetworkConnection)
I>            .Where(nc => (nc != null))
I>            .Execute(nc => Collect(nc, protection));
I>     }
I>

      foreach (var ss in new[] { sr.WorkingSegments, sr.ProtectionSegments })
        foreach (ServiceSegment s in ss)
          foreach (SegmentParcel p in s.SegmentParcels)
          {
            if (p.NetworkConnection != null)
              Collect(p.NetworkConnection, protection);
          }

      IEnumerable<ServiceSegment> segments = _.Combine(sr.WorkingSegments, sr.ProtectionSegments);

      foreach (var ss in new IEnumerable[] { sr.WorkingSegments, sr.ProtectionSegments })
        foreach (ServiceSegment s in ss)
          foreach (SegmentParcel p in s.SegmentParcels)
          {
            if (p.NetworkConnection != null)
              Collect(p.NetworkConnection, protection);
          }

var matches = from item in items 
              where criteria.All(
                criterion=>criterion.IsMetBy(item)) 
              select item;
match = matches.FirstOrDefault();

      foreach (var item in items)
      {
        if (criteria.All(criterion => criterion.IsMetBy(item)))
        {
          match = item;
          break;
        }
      }

      int? match = null;
      foreach (var item in items)
      {
        if (criteria.All(criterion => criterion.IsMetBy(item)))
        {
          match = item;
          break;
        }
      }

class _
{
}

public static T? FirstOrNull<T>(this IEnumerable<T> en) where T: struct
{
    return en.Count() > 0 ? (T?)en.First() : null;
}

U>class _
U>{
U>}
U>

Some _ = new Some();

class _
{
  public IEnumerable<T> Combine<T>(params IEnumerable<T>[] collections)
  {
  }
}

I>Твой код не работает потому что ss имеет тип ServiceSegmentCollection [] те. нужен еще один foreach

      foreach (var ss in new IEnumerable[] { sr.WorkingSegments, sr.ProtectionSegments })
        foreach (ServiceSegment s in ss)
          foreach (SegmentParcel p in s.SegmentParcels)
          {
            if (p.NetworkConnection != null)
              Collect(p.NetworkConnection, protection);
          }

IEnumerable<T> GetBlah(IEnumerable<T> items)
{
   foreach (T item in items)
    if (criteria.All(c => c.IsMetBy(item)))
      yield return item;
   yield break;
}

if(!GetBlah(items).MoveNext)
   throw new Exception(Res.BlahTargetNotFound);

Проблема сложных алгоритмов, что они имеют сложное промежуточное состояние.

      int certifiedStationIndex = -1; //последняя остановка пройденная по расписанию
      StationIntervalWithIndex unexpectedInterval = null; //остановка пройденная вне очереди (если есть)
      Dictionary<Tuple2<int, DateTime>, bool> undoneArrivalIntervals = new Dictionary<Tuple2<int, DateTime>, bool>(); //остановки, на которые мы в текущий момент уже въехали, но еще из них не выехали

I>>GetRouting(selection).DisposeAll();

DisposableHelper.DisposeAll(GetRouting(selection));

import Data.Time

type Pos = (Double,Double)

dist :: Pos -> Pos -> Double
dist (x1,y1) (x2,y2) = sqrt (x' * x' + y' * y')
                       where x' = x1 - x2
                             y' = y1 - y2

type ScheduleItem = (Int, DiffTime)
type Schedule =  [ScheduleItem]
type Track =     [(Pos, DiffTime)]
type Stations =  [Pos]

stations = [...]::Stations

getTrackSegmentWithinRadius :: Double -> Pos -> Track -> (Track, Track)
getTrackSegmentWithinRadius radius pos track =
    span (\(p,_) ->  dist pos p < radius) $ dropWhile (\(p,_) ->  dist pos p > radius) track


data StationPassStatus = InTime | Late | Early | NotPassed
                         deriving(Eq,Show)

getStationPassStatus :: DiffTime -> Track -> StationPassStatus
getStationPassStatus stationTime segment = 
    if null segment
        then NotPassed
        else
            --Super complex logic
            InTime 
            where times = map snd segment
                  min = minimum times
                  max = maximum times

getScheduleDiff :: Double -> Schedule -> Track -> [(Int, StationPassStatus)]
getScheduleDiff radius s track =
    drop 1 $
    map (\(_,a,b) -> (a,b)) $
    scanr (\(stationId, t) -> \(track,_,_) -> 
        let (seg, track') = getTrackSegmentWithinRadius radius (stations!!stationId) track
            status = getStationPassStatus t seg
        in (track', stationId, status)) (track, 0, NotPassed) s