Collections Data Structure C#

#region License
// Copyright 2006 James Newton-King
// http://www.newtonsoft.com
//
// This work is licensed under the Creative Commons Attribution 2.5 License
// http://creativecommons.org/licenses/by/2.5/
//
// You are free:
//    * to copy, distribute, display, and perform the work
//    * to make derivative works
//    * to make commercial use of the work
//
// Under the following conditions:
//    * You must attribute the work in the manner specified by the author or licensor:
//          - If you find this component useful a link to http://www.newtonsoft.com would be appreciated.
//    * For any reuse or distribution, you must make clear to others the license terms of this work.
//    * Any of these conditions can be waived if you get permission from the copyright holder.
#endregion
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace MySpace.Common.IO.JSON.Utilities
{
    internal static class CollectionUtils
    {
        /// 
        /// Makes a slice of the specified list in between the start and end indexes.
        /// 

        /// The list.
        /// The start index.
        /// The end index.
        /// A slice of the list.
        public static IList Slice(IList list, int? start, int? end)
        {
            return Slice(list, start, end, null);
        }
        /// 
        /// Makes a slice of the specified list in between the start and end indexes,
        /// getting every so many items based upon the step.
        /// 

        /// The list.
        /// The start index.
        /// The end index.
        /// The step.
        /// A slice of the list.
        public static IList Slice(IList list, int? start, int? end, int? step)
        {
            if (list == null)
                throw new ArgumentNullException("list");
            if (step == 0)
                throw new ArgumentException("Step cannot be zero.", "step");
            List slicedList = new List();
            // nothing to slice
            if (list.Count == 0)
                return slicedList;
            // set defaults for null arguments
            int s = step ?? 1;
            int startIndex = start ?? 0;
            int endIndex = end ?? list.Count;
            // start from the end of the list if start is negitive
            startIndex = (startIndex < 0) ? list.Count + startIndex : startIndex;
            // end from the start of the list if end is negitive
            endIndex = (endIndex < 0) ? list.Count + endIndex : endIndex;
            // ensure indexes keep within collection bounds
            startIndex = Math.Max(startIndex, 0);
            endIndex = Math.Min(endIndex, list.Count - 1);
            // loop between start and end indexes, incrementing by the step
            for (int i = startIndex; i < endIndex; i += s)
            {
                slicedList.Add(list[i]);
            }
            return slicedList;
        }
    }
}