public void Reverse_NegativeParameters(int listLength) { if (listLength % 2 != 0) { listLength++; } SegmentedList <T> list = GenericListFactory(listLength); Tuple <int, int>[] InvalidParameters = new Tuple <int, int>[] { Tuple.Create(-1, -1), Tuple.Create(-1, 0), Tuple.Create(-1, 1), Tuple.Create(-1, 2), Tuple.Create(0, -1), Tuple.Create(1, -1), Tuple.Create(2, -1), }; Assert.All( InvalidParameters, invalidSet => { Assert.Throws <ArgumentOutOfRangeException>( () => list.Reverse(invalidSet.Item1, invalidSet.Item2) ); } ); }
public void RemoveRange_InvalidParameters(int listLength) { if (listLength % 2 != 0) { listLength++; } SegmentedList <T> list = GenericListFactory(listLength); Tuple <int, int>[] InvalidParameters = new Tuple <int, int>[] { Tuple.Create(listLength, 1), Tuple.Create(listLength + 1, 0), Tuple.Create(listLength + 1, 1), Tuple.Create(listLength, 2), Tuple.Create(listLength / 2, listLength / 2 + 1), Tuple.Create(listLength - 1, 2), Tuple.Create(listLength - 2, 3), Tuple.Create(1, listLength), Tuple.Create(0, listLength + 1), Tuple.Create(1, listLength + 1), Tuple.Create(2, listLength), Tuple.Create(listLength / 2 + 1, listLength / 2), Tuple.Create(2, listLength - 1), Tuple.Create(3, listLength - 2), }; Assert.All(InvalidParameters, invalidSet => { if (invalidSet.Item1 >= 0 && invalidSet.Item2 >= 0) { Assert.Throws <ArgumentException>(null, () => list.RemoveRange(invalidSet.Item1, invalidSet.Item2)); } }); }
public void TrueForAll_VerifyVanilla(T[] items) { T?expectedItem = default(T); SegmentedList <T> list = new SegmentedList <T>(); Predicate <T> expectedItemDelegate = delegate(T item) { return(expectedItem == null ? item != null : !expectedItem.Equals(item)); }; bool typeNullable = default(T) == null; for (int i = 0; i < items.Length; ++i) { list.Add(items[i]); } //[] Verify TrueForAll looks at every item for (int i = 0; i < items.Length; ++i) { expectedItem = items[i]; Assert.False(list.TrueForAll(expectedItemDelegate)); //"Err_282308ahid Verify TrueForAll looks at every item FAILED\n" } //[] Verify TrueForAll returns true if the match returns true on every item Assert.True(list.TrueForAll(delegate(T item) { return(true); }), "Err_548ahid Verify TrueForAll returns true if the match returns true on every item FAILED\n"); //[] Verify TrueForAll returns false if the match returns false on every item Assert.True((0 == items.Length) == list.TrueForAll(delegate(T item) { return(false); }), "Err_30848ahidi Verify TrueForAll returns " + (0 == items.Length) + " if the match returns false on every item FAILED\n"); }
public void NonGenericIListBasicInsert(T?[] items, T?item, int index, int repeat) { SegmentedList <T?> list = new SegmentedList <T?>(items); IList _ilist = list; for (int i = 0; i < repeat; i++) { _ilist.Insert(index, item); } Assert.True(list.Contains(item)); //"Expected it to be true." Assert.Equal(list.Count, items.Length + repeat); //"Expected them to be equal." for (int i = 0; i < index; i++) { Assert.Equal(list[i], items[i]); //"Expected them to be equal." } for (int i = index; i < index + repeat; i++) { Assert.Equal((object?)list[i], item); //"Expected them to be equal." } for (int i = index + repeat; i < list.Count; i++) { Assert.Equal(list[i], items[i - repeat]); //"Expected them to be equal." } }
public void LastIndexOf_int_OrderIsCorrectWithManyDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> withoutDuplicates = list.ToSegmentedList(); list.AddRange(list); list.AddRange(list); list.AddRange(list); Assert.All( Enumerable.Range(0, count), i => { Assert.All( Enumerable.Range(0, 4), j => { int expectedIndex = (j * count) + i; Assert.Equal( expectedIndex, list.LastIndexOf(withoutDuplicates[i], (count * (j + 1)) - 1) ); Assert.Equal( expectedIndex, list.LastIndexOf(withoutDuplicates[i], (count * (j + 1)) - 1, count) ); } ); } ); }
public void BasicInsert(T?[] items, T?item, int index, int repeat) { SegmentedList <T?> list = new SegmentedList <T?>(items); for (int i = 0; i < repeat; i++) { list.Insert(index, item); } Assert.True(list.Contains(item)); //"Expect it to contain the item." Assert.Equal(list.Count, items.Length + repeat); //"Expect to be the same." for (int i = 0; i < index; i++) { Assert.Equal(list[i], items[i]); //"Expect to be the same." } for (int i = index; i < index + repeat; i++) { Assert.Equal(list[i], item); //"Expect to be the same." } for (int i = index + repeat; i < list.Count; i++) { Assert.Equal(list[i], items[i - repeat]); //"Expect to be the same." } }
public void FindLast_VerifyDuplicates(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); T?foundItem; Predicate <T?> EqualsDelegate = (T? item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; if (0 < count) { list.Add(beforeList[0]); //[] Verify first item is duplicated expectedItem = beforeList[0]; foundItem = list.FindLast(EqualsDelegate); Assert.Equal(beforeList[0], foundItem); //"Err_2879072qaiadf Verify first item is duplicated FAILED\n" } if (1 < count) { list.Add(beforeList[1]); //[] Verify second item is duplicated expectedItem = beforeList[1]; foundItem = list.FindLast(EqualsDelegate); Assert.Equal(beforeList[1], foundItem); //"Err_4588ajdia Verify second item is duplicated FAILED\n" //[] Verify with match that matches more then one item foundItem = list.FindLast((T item) => { return(item != null && (item.Equals(beforeList[0]) || item.Equals(beforeList[1]))); }); Assert.Equal(beforeList[1], foundItem); //"Err_4489ajodoi Verify with match that matches more then one item FAILED\n" } }
public void IndexOf_NonExistingValues( IndexOfMethod indexOfMethod, int count, bool frontToBackOrder ) { _ = frontToBackOrder; SegmentedList <T> list = GenericListFactory(count); IEnumerable <T> nonexistentValues = CreateEnumerable( EnumerableType.List, list, count: count, numberOfMatchingElements: 0, numberOfDuplicateElements: 0 ); IndexOfDelegate IndexOf = IndexOfDelegateFromType(indexOfMethod); Assert.All( nonexistentValues, nonexistentValue => { Assert.Equal(-1, IndexOf(list, nonexistentValue)); } ); }
/// <summary> /// Create a IStreamReader (reads binary data) from a given subregion of a byte buffer /// </summary> public SegmentedMemoryStreamReader(SegmentedList <byte> data, int start, int length) { bytes = new SegmentedList <byte>(65_536, length); bytes.AppendFrom(data, start, length); position = start; endPosition = length; }
public void Find_VerifyVanilla(int count) { SegmentedList <T?> list = GenericListFactory(count) !; SegmentedList <T?> beforeList = list.ToSegmentedList(); T?expectedItem = default(T); T?foundItem; Predicate <T?> EqualsDelegate = (T? item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; //[] Verify Find returns the correct index for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; foundItem = list.Find(EqualsDelegate); Assert.Equal(expectedItem, foundItem); //"Err_282308ahid Verifying value returned from Find FAILED\n" } //[] Verify Find returns the first item if the match returns true on every item foundItem = list.Find(_alwaysTrueDelegate); Assert.Equal(0 < count ? beforeList[0] : default(T), foundItem); //"Err_548ahid Verify Find returns the first item if the match returns true on every item FAILED\n" //[] Verify Find returns T.Default if the match returns false on every item foundItem = list.Find(_alwaysFalseDelegate); Assert.Equal(default(T), foundItem); //"Err_30848ahidi Verify Find returns T.Default if the match returns false on every item FAILED\n" //[] Verify with default(T) list.Add(default(T)); foundItem = list.Find((T? item) => { return(item == null ? default(T) == null : item.Equals(default(T))); }); Assert.Equal(default(T), foundItem); //"Err_541848ajodi Verify with default(T) FAILED\n" list.RemoveAt(list.Count - 1); }
public void Sort_intintIComparer_NegativeRange_ThrowsArgumentOutOfRangeException(int count) { SegmentedList <T> list = GenericListFactory(count); Tuple <int, int>[] InvalidParameters = new Tuple <int, int>[] { Tuple.Create(-1, -1), Tuple.Create(-1, 0), Tuple.Create(-1, 1), Tuple.Create(-1, 2), Tuple.Create(-2, 0), Tuple.Create(int.MinValue, 0), Tuple.Create(0, -1), Tuple.Create(0, -2), Tuple.Create(0, int.MinValue), Tuple.Create(1, -1), Tuple.Create(2, -1), }; Assert.All( InvalidParameters, invalidSet => { Assert.Throws <ArgumentOutOfRangeException>( () => list.Sort(invalidSet.Item1, invalidSet.Item2, GetIComparer()) ); } ); }
/// <summary> /// Create a IStreamReader (reads binary data) from a given subregion of a byte buffer /// </summary> public SegmentedMemoryStreamReader(SegmentedList <byte> data, long start, long length, SerializationConfiguration config = null) { SerializationConfiguration = config ?? new SerializationConfiguration(); if (SerializationConfiguration.StreamLabelWidth == StreamLabelWidth.FourBytes) { readLabel = () => { return((StreamLabel)(uint)ReadInt32()); }; sizeOfSerializedStreamLabel = 4; } else { readLabel = () => { return((StreamLabel)(ulong)ReadInt64()); }; sizeOfSerializedStreamLabel = 8; } bytes = new SegmentedList <byte>(65_536, length); bytes.AppendFrom(data, start, length); position = start; endPosition = length; }
protected override SegmentedList <PointDouble> CreateShape(SegmentedList <PointDouble> tracePoints) { RectDouble num5; PointDouble a = tracePoints[0]; PointDouble b = tracePoints[tracePoints.Count - 1]; PointDouble num3 = new PointDouble(b.X - a.X, b.Y - a.Y); double num4 = Math.Sqrt((num3.X * num3.X) + (num3.Y * num3.Y)); if ((base.ModifierKeys & Keys.Shift) != Keys.None) { PointDouble center = new PointDouble((a.X + b.X) / 2.0, (a.Y + b.Y) / 2.0); double num7 = num4 / 2.0; num5 = RectDouble.FromCenter(center, (double)(num7 * 2.0)); } else { num5 = RectDoubleUtil.FromPixelPoints(a, b); } PdnGraphicsPath path = new PdnGraphicsPath(); path.AddEllipse(num5.ToGdipRectangleF()); using (Matrix matrix = new Matrix()) { path.Flatten(matrix, 0.1f); } SegmentedList <PointDouble> list = new SegmentedList <PointDouble>(path.PathPoints.Select <PointF, PointDouble>(pt => pt.ToDoublePoint()), 7); path.Dispose(); return(list); }
public override HistoryMemento OnExecute(IHistoryWorkspace historyWorkspace) { SelectionData state = null; SegmentedList <HistoryMemento> actions = new SegmentedList <HistoryMemento>(); if (!historyWorkspace.Selection.IsEmpty) { state = historyWorkspace.Selection.Save(); HistoryMemento memento3 = new DeselectFunction().Execute(historyWorkspace); actions.Add(memento3); } ReplaceDocumentHistoryMemento item = new ReplaceDocumentHistoryMemento(null, null, historyWorkspace); actions.Add(item); CompoundHistoryMemento memento2 = new CompoundHistoryMemento(StaticName, PdnResources.GetImageResource("Icons.MenuImageFlattenIcon.png"), actions); Document document = RetryManager.RunMemorySensitiveOperation <Document>(() => historyWorkspace.Document.Flatten()); base.EnterCriticalRegion(); historyWorkspace.Document = document; if (state != null) { SelectionHistoryMemento newHA = new SelectionHistoryMemento(null, null, historyWorkspace); historyWorkspace.Selection.Restore(state); memento2.AddMemento(newHA); } return(memento2); }
public void FindLastIndexInt_VerifyExceptions(int count) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); Predicate <T> predicate = _alwaysTrueDelegate; //[] Verify Null match Assert.Throws <ArgumentNullException>(() => list.FindLastIndex(0, null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" /****************************************************************************** * index ******************************************************************************/ //[] Verify index=Int32.MinValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(int.MinValue, predicate)); //"Err_948ahid Expected index=Int32.MinValue to throw ArgumentOutOfRangeException" if (0 < list.Count) { //[] Verify index=-1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(-1, predicate)); //"Err_328ahuaw Expected index=-1 to throw ArgumentOutOfRangeException" } //[] Verify index=list.Count + 1 Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(list.Count + 1, predicate)); //"Err_488ajdi Expected index=list.Count + 1 to throw ArgumentOutOfRangeException" //[] Verify index=list.Count Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(list.Count, predicate)); //"Err_9689ajis Expected index=list.Count to throw ArgumentOutOfRangeException" //[] Verify index=Int32.MaxValue Assert.Throws <ArgumentOutOfRangeException>(() => list.FindLastIndex(int.MaxValue, predicate)); //"Err_238ajwisa Expected index=Int32.MaxValue to throw ArgumentOutOfRangeException" }
private IHandler[] GetHandlersNoLock(Type service) { //we have 3 segments const int defaults = 0; const int regulars = 1; const int fallbacks = 2; var handlers = new SegmentedList <IHandler>(3); foreach (var handler in name2Handler.Values) { if (handler.Supports(service) == false) { continue; } if (IsDefault(handler, service)) { handlers.AddFirst(defaults, handler); continue; } if (IsFallback(handler, service)) { handlers.AddLast(fallbacks, handler); continue; } handlers.AddLast(regulars, handler); } return(handlers.ToArray()); }
public void FindLastIndex_VerifyVanilla(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int index; Predicate <T> EqualsDelegate = delegate(T item) { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; //[] Verify FinIndex returns the correct index for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; index = list.FindLastIndex(EqualsDelegate); Assert.Equal(i, index); //"Err_282308ahid Expected FindLastIndex to return the same." } //[] Verify FindLastIndex returns 0 if the match returns true on every item int expected = count == 0 ? -1 : count - 1; index = list.FindLastIndex(_alwaysTrueDelegate); Assert.Equal(expected, index); //"Err_15198ajid Verify FindLastIndex returns 0 if the match returns true on every item" //[] Verify FindLastIndex returns -1 if the match returns false on every item index = list.FindLastIndex(_alwaysFalseDelegate); Assert.Equal(-1, index); //"Err_305981ajodd Verify FindLastIndex returns -1 if the match returns false on every item" }
public void IndexOf_OrderIsCorrect( IndexOfMethod indexOfMethod, int count, bool frontToBackOrder ) { SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> withoutDuplicates = list.ToSegmentedList(); list.AddRange(list); IndexOfDelegate IndexOf = IndexOfDelegateFromType(indexOfMethod); Assert.All( Enumerable.Range(0, count), i => { if (frontToBackOrder) { Assert.Equal(i, IndexOf(list, withoutDuplicates[i])); } else { Assert.Equal(count + i, IndexOf(list, withoutDuplicates[i])); } } ); }
public void FindLastIndexIntInt_VerifyDuplicates(int count) { T?expectedItem = default(T); SegmentedList <T> list = GenericListFactory(count); SegmentedList <T> beforeList = list.ToSegmentedList(); int index; Predicate <T> EqualsDelegate = (T item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; if (0 < count) { list.Add(beforeList[0]); //[] Verify first item is duplicated expectedItem = beforeList[0]; index = list.FindLastIndex(list.Count - 1, list.Count, EqualsDelegate); Assert.Equal(list.Count - 1, index); //"Err_3282iahid Verify first item is duplicated" } if (1 < count) { list.Add(beforeList[1]); //[] Verify second item is duplicated expectedItem = beforeList[1]; index = list.FindLastIndex(list.Count - 1, list.Count, EqualsDelegate); Assert.Equal(list.Count - 1, index); //"Err_29892adewiu Verify second item is duplicated" } }
private void Exists_VerifyVanilla(T[] items) { T?expectedItem = default(T); SegmentedList <T?> list = new SegmentedList <T?>(); Predicate <T?> expectedItemDelegate = (T? item) => { return(expectedItem == null ? item == null : expectedItem.Equals(item)); }; bool typeNullable = default(T) == null; for (int i = 0; i < items.Length; ++i) { list.Add(items[i]); } //[] Verify Exists returns the correct index for (int i = 0; i < items.Length; ++i) { expectedItem = items[i]; Assert.True(list.Exists(expectedItemDelegate), "Err_282308ahid Verifying Nullable returned FAILED\n"); } //[] Verify Exists returns true if the match returns true on every item Assert.True((0 < items.Length) == list.Exists((T? item) => { return(true); }), "Err_548ahid Verify Exists returns 0 if the match returns true on every item FAILED\n"); //[] Verify Exists returns false if the match returns false on every item Assert.True(!list.Exists((T? item) => { return(false); }), "Err_30848ahidi Verify Exists returns -1 if the match returns false on every item FAILED\n"); //[] Verify with default(T) list.Add(default(T)); Assert.True(list.Exists((T? item) => { return(item == null ? default(T) == null : item.Equals(default(T))); }), "Err_541848ajodi Verify with default(T) FAILED\n"); list.RemoveAt(list.Count - 1); }
public void FindAll_VerifyDuplicates(int count) { SegmentedList <T> list = GenericListFactory(count); for (int i = 0; i < count / 2; i++) { list.Add(list[i]); } SegmentedList <T> beforeList = list.ToSegmentedList(); T? expectedItem = default(T); Predicate <T> EqualsDelegate = (value) => expectedItem == null ? value == null : expectedItem.Equals(value); //[] Verify FindAll returns the correct List with one item for (int i = 0; i < count; ++i) { expectedItem = beforeList[i]; SegmentedList <T> results = list.FindAll(EqualsDelegate); VerifyList(results, beforeList.Where((value) => EqualsDelegate(value)).ToSegmentedList()); } //[] Verify FindAll returns an List with all of the items if the predicate always returns true VerifyList(list.FindAll(_alwaysTrueDelegate), beforeList); //[] Verify FindAll returns an empty List if the match returns false on every item VerifyList(list.FindAll(_alwaysFalseDelegate), new SegmentedList <T>()); }
public void ClearNonEmptyList(T[] items) { SegmentedList <T> list = new SegmentedList <T>(items); list.Clear(); Assert.Equal(0, list.Count); //"Should be equal to 0." }
private Rectangle[] ConsolidateRects(Rectangle[] scans) { if (scans.Length == 0) { return(Array.Empty <Rectangle>()); } SegmentedList <Rectangle> cons = new SegmentedList <Rectangle>(); int current = 0; cons.Add(scans[0]); for (int i = 1; i < scans.Length; ++i) { if (scans[i].Left == cons[current].Left && scans[i].Right == cons[current].Right && scans[i].Top == cons[current].Bottom) { Rectangle cc = cons[current]; cc.Height = scans[i].Bottom - cons[current].Top; cons[current] = cc; } else { cons.Add(scans[i]); current = cons.Count - 1; } } return(cons.ToArrayEx()); }
public void TrueForAll_VerifyExceptions(T[] items) { var list = new SegmentedList <T>(items); Assert.True(list.TrueForAll(item => true)); Assert.Throws <ArgumentNullException>(() => list.TrueForAll(null !)); //"Err_858ahia Expected null match to throw ArgumentNullException" }
public void CopyTo_ArgumentValidity(int count) { SegmentedList <T> list = GenericListFactory(count); Assert.Throws <ArgumentException>(null, () => list.CopyTo(0, new T[0], 0, count + 1)); Assert.Throws <ArgumentException>(null, () => list.CopyTo(count, new T[0], 0, 1)); }
public TokenStream(TreeData treeData, SyntaxFormattingOptions options, TextSpan spanToFormat, AbstractTriviaDataFactory factory) { using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None)) { // initialize basic info _factory = factory; _treeData = treeData; _options = options; // use some heuristics to get initial size of list rather than blindly start from default size == 4 var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio; _tokens = new SegmentedList <SyntaxToken>(sizeOfList); _tokens.AddRange(_treeData.GetApplicableTokens(spanToFormat)); Debug.Assert(this.TokenCount > 0); // initialize trivia related info _cachedOriginalTriviaInfo = new SegmentedArray <TriviaData>(this.TokenCount - 1); // Func Cache _getTriviaData = this.GetTriviaData; _getOriginalTriviaData = this.GetOriginalTriviaData; } DebugCheckTokenOrder(); }
public void Constructor_IEnumerable( EnumerableType enumerableType, int listLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements ) { _ = listLength; _ = numberOfMatchingElements; IEnumerable <T> enumerable = CreateEnumerable( enumerableType, null, enumerableLength, 0, numberOfDuplicateElements ); SegmentedList <T> list = new SegmentedList <T>(enumerable); SegmentedList <T> expected = enumerable.ToSegmentedList(); Assert.Equal(enumerableLength, list.Count); //"Number of items in list do not match the number of items given." for (int i = 0; i < enumerableLength; i++) { Assert.Equal(expected[i], list[i]); //"Expected object in item array to be the same as in the list" } Assert.False(((IList <T>)list).IsReadOnly); //"List should not be readonly" }
public void Reverse_RepeatedValues(int listLength, int index, int count) { SegmentedList <T> list = GenericListFactory(1); for (int i = 1; i < listLength; i++) { list.Add(list[0]); } SegmentedList <T> listBefore = list.ToSegmentedList(); list.Reverse(index, count); for (int i = 0; i < index; i++) { Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same." } int j = 0; for (int i = index; i < index + count; i++) { Assert.Equal(list[i], listBefore[index + count - (j + 1)]); //"Expect them to be the same." j++; } for (int i = index + count; i < listBefore.Count; i++) { Assert.Equal(list[i], listBefore[i]); //"Expect them to be the same." } }
internal Enumerator(SegmentedList <T> list) { _list = list; _index = 0; _version = list._version; _current = default; }
private Rectangle[] ConsolidateRects(Rectangle[] scans) { if (scans.Length == 0) { return(Array.Empty <Rectangle>()); } SegmentedList <Rectangle> items = new SegmentedList <Rectangle>(); int num = 0; items.Add(scans[0]); for (int i = 1; i < scans.Length; i++) { Rectangle rectangle = items[num]; if (scans[i].Left == rectangle.Left) { rectangle = items[num]; if (scans[i].Right == rectangle.Right) { rectangle = items[num]; if (scans[i].Top == rectangle.Bottom) { Rectangle rectangle2 = items[num]; rectangle = items[num]; rectangle2.Height = scans[i].Bottom - rectangle.Top; items[num] = rectangle2; continue; } } } items.Add(scans[i]); num = items.Count - 1; } return(items.ToArrayEx <Rectangle>()); }
private IHandler[] GetHandlersNoLock(Type service) { //we have 3 segments const int defaults = 0; const int regulars = 1; const int fallbacks = 2; var handlers = new SegmentedList<IHandler>(3); foreach (var handler in name2Handler.Values) { if (handler.Supports(service) == false) { continue; } if (IsDefault(handler, service)) { handlers.AddFirst(defaults, handler); continue; } if (IsFallback(handler, service)) { handlers.AddLast(fallbacks, handler); continue; } handlers.AddLast(regulars, handler); } return handlers.ToArray(); }