使用扩展方法:

public static T[] Slice<T>(this T[] source, int start, int end)
    {
        // Handles negative ends.
        if (end < 0)
        {
            end = source.Length + end;
        }
        int len = end - start;

        // Return new array.
        T[] res = new T[len];
        for (int i = 0; i < len; i++)
        {
            res[i] = source[i + start];
        }
        return res;
    }

你可以使用它

var NewArray = OldArray.Slice(3,7);

我看到你想做克隆，而不仅仅是复制引用。 在这种情况下，您可以使用. select将数组成员投射到它们的克隆体。 例如，如果你的元素实现了IClonable，你可以这样做:

var newArray = array.Skip(3).Take(5).Select(eachElement => eachElement.Clone()).ToArray();

注意:此解决方案需要。net Framework 3.5。

public   static   T[]   SubArray<T>(T[] data, int index, int length)
        {
            List<T> retVal = new List<T>();
            if (data == null || data.Length == 0)
                return retVal.ToArray();
            bool startRead = false;
            int count = 0;
            for (int i = 0; i < data.Length; i++)
            {
                if (i == index && !startRead)
                    startRead = true;
                if (startRead)
                {

                    retVal.Add(data[i]);
                    count++;

                    if (count == length)
                        break;
                }
            }
            return retVal.ToArray();
        }

就克隆而言，我认为序列化不会调用构造函数。如果你在ctor中做一些有趣的事情，这可能会破坏类不变量。

似乎更安全的方法是调用复制构造函数的虚拟克隆方法。

protected MyDerivedClass(MyDerivedClass myClass) 
{
  ...
}

public override MyBaseClass Clone()
{
  return new MyDerivedClass(this);
}

这很容易做到;

    object[] foo = new object[10];
    object[] bar = new object[7];   
    Array.Copy(foo, 3, bar, 0, 7);  

我认为你要找的代码是:

阵列。复制(oldArray, 0, newArray，开始，EndIndex -开始)