ได้รับการย่อยจากอาร์เรย์ที่มีอยู่

ฉันมีอาร์เรย์ X 10 องค์ประกอบ ฉันต้องการสร้างอาร์เรย์ใหม่ที่มีองค์ประกอบทั้งหมดจาก X ที่เริ่มต้นที่ดัชนี 3 และสิ้นสุดในดัชนี 7 แน่นอนฉันสามารถเขียนลูปที่จะทำเพื่อฉันได้ง่าย แต่ฉันต้องการให้โค้ดของฉันสะอาดที่สุดเท่าที่จะทำได้ . มีวิธีการใน C # ที่สามารถทำได้สำหรับฉัน

บางสิ่งที่ชอบ (รหัสหลอก):

Array NewArray = oldArray.createNewArrayFromRange(int BeginIndex , int EndIndex)

Array.Copyไม่พอดีกับความต้องการของฉัน ฉันต้องการไอเท็มในแถวลำดับใหม่เพื่อทำการโคลน Array.copyมันmemcpyเทียบเท่าC-Style ไม่ใช่สิ่งที่ฉันกำลังมองหา

คุณสามารถเพิ่มเป็นวิธีส่วนขยาย:

public static T[] SubArray<T>(this T[] data, int index, int length)
{
    T[] result = new T[length];
    Array.Copy(data, index, result, 0, length);
    return result;
}
static void Main()
{
    int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int[] sub = data.SubArray(3, 4); // contains {3,4,5,6}
}

อัปเดตการโคลนใหม่ (ซึ่งไม่ชัดเจนในคำถามเดิม) หากคุณจริงๆต้องการโคลนลึก สิ่งที่ต้องการ:

public static T[] SubArrayDeepClone<T>(this T[] data, int index, int length)
{
    T[] arrCopy = new T[length];
    Array.Copy(data, index, arrCopy, 0, length);
    using (MemoryStream ms = new MemoryStream())
    {
        var bf = new BinaryFormatter();
        bf.Serialize(ms, arrCopy);
        ms.Position = 0;
        return (T[])bf.Deserialize(ms);
    }
}

สิ่งนี้ต้องการวัตถุที่จะเป็นอนุกรม ( [Serializable]หรือISerializable) แม้ว่า คุณสามารถจะทดแทนการ serializer อื่น ๆ ตามความเหมาะสม - XmlSerializer, DataContractSerializer, protobuf สุทธิ ฯลฯ

โปรดทราบว่าการโคลนแบบลึกนั้นมีความซับซ้อนโดยไม่ทำให้เป็นอันดับ โดยเฉพาะอย่างยิ่งICloneableยากที่จะเชื่อใจในกรณีส่วนใหญ่

คุณสามารถใช้Array.Copy(...)เพื่อคัดลอกไปยังอาเรย์ใหม่หลังจากที่คุณสร้างมันขึ้นมา แต่ฉันไม่คิดว่าจะมีวิธีการที่จะสร้างอาเรย์ใหม่และคัดลอกองค์ประกอบต่าง ๆ

หากคุณใช้. NET 3.5 คุณสามารถใช้ LINQ:

var newArray = array.Skip(3).Take(5).ToArray();

แต่นั่นจะค่อนข้างมีประสิทธิภาพน้อยกว่า

ดูคำตอบสำหรับคำถามที่คล้ายกันนี้สำหรับตัวเลือกสำหรับสถานการณ์เฉพาะเพิ่มเติม

คุณเคยคิดจะใช้ArraySegmentไหม?

http://msdn.microsoft.com/en-us/library/1hsbd92d.aspx

ฉันเห็นว่าคุณต้องการทำการโคลนไม่ใช่แค่คัดลอกข้อมูลอ้างอิง ในกรณีนี้คุณสามารถใช้.Selectโปรเจ็กต์สมาชิกอาเรย์กับโคลนนิ่งของพวกเขา ตัวอย่างเช่นหากองค์ประกอบของคุณมีการใช้งานIClonableคุณสามารถทำสิ่งนี้:

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

หมายเหตุ: โซลูชันนี้ต้องการ. NET Framework 3.5

รหัสต่อไปนี้ทำได้ในหนึ่งบรรทัด:

// Source array
string[] Source = new string[] { "A", "B", "C", "D" };
// Extracting a slice into another array
string[] Slice = new List<string>(Source).GetRange(2, 2).ToArray();

ใน C # 8 พวกเขาได้แนะนำสิ่งใหม่RangeและIndexประเภท

int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Index i1 = 3;  // number 3 from beginning
Index i2 = ^4; // number 4 from end
var slice = a[i1..i2]; // { 3, 4, 5 }

string[] arr = { "Parrot" , "Snake" ,"Rabbit" , "Dog" , "cat" };

arr = arr.ToList().GetRange(0, arr.Length -1).ToArray();

สร้างคำตอบของ Marc แต่เพิ่มพฤติกรรมการโคลนที่ต้องการ

public static T[] CloneSubArray<T>(this T[] data, int index, int length)
    where T : ICloneable
{
    T[] result = new T[length];
    for (int i = 0; i < length; i++)
    { 
        var original = data[index + i];
        if (original != null)
            result[i] = (T)original.Clone();            
    return result;
}

และหากการติดตั้ง ICloneable เป็นงานที่หนักหน่วงเกินกว่าที่จะใช้งานไลบรารี่แบบไตร่ตรองโดยใช้ไลบรารี่ที่คัดลอกได้ของHåvard Strandenเพื่อใช้ในการยกของหนัก

using OX.Copyable;

public static T[] DeepCopySubArray<T>(
    this T[] data, int index, int length)
{
    T[] result = new T[length];
    for (int i = 0; i < length; i++)
    { 
        var original = data[index + i];
        if (original != null)
            result[i] = (T)original.Copy();            
    return result;
}

โปรดทราบว่าการใช้ OX.Copyable ทำงานได้กับ:

เพื่อให้การคัดลอกอัตโนมัติทำงานแม้ว่าข้อความใดข้อความหนึ่งต่อไปนี้จะต้องถูกระงับเช่น:

• ประเภทของมันจะต้องมีคอนสตรัคเตอร์แบบไม่มีพารามิเตอร์หรือ
• ต้องเป็นแบบคัดลอกได้หรือ
• ต้องมีการลงทะเบียน IInstanceProvider สำหรับประเภทของมัน

ดังนั้นสิ่งนี้ควรจะครอบคลุมสถานการณ์ที่คุณมี หากคุณโคลนวัตถุที่กราฟย่อยมีสิ่งต่าง ๆ เช่นการเชื่อมต่อ db หรือไฟล์ / สตรีมจัดการคุณเห็นได้ชัดว่ามีปัญหา แต่มันเป็นจริงสำหรับสำเนาลึกทั่วไปใด ๆ

หากคุณต้องการใช้วิธีการทำสำเนาแบบลึกอื่น ๆ แทนบทความนี้แสดงรายการอื่น ๆ หลายวิธีดังนั้นฉันขอแนะนำว่าอย่าพยายามเขียนของคุณเอง

คุณสามารถทำได้ค่อนข้างง่าย

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

ฉันคิดว่ารหัสที่คุณต้องการคือ:

Array.Copy(oldArray, 0, newArray, BeginIndex, EndIndex - BeginIndex)

เป็นอีกทางเลือกหนึ่งในการคัดลอกข้อมูลคุณสามารถสร้าง wrapper ที่ให้คุณสามารถเข้าถึงส่วนหนึ่งของอาร์เรย์เดิมได้ราวกับว่ามันเป็นสำเนาของส่วนหนึ่งของอาร์เรย์ ข้อดีคือคุณจะไม่ได้รับสำเนาของข้อมูลในหน่วยความจำอีกและข้อเสียเปรียบคือค่าใช้จ่ายเล็กน้อยเมื่อเข้าถึงข้อมูล

public class SubArray<T> : IEnumerable<T> {

   private T[] _original;
   private int _start;

   public SubArray(T[] original, int start, int len) {
      _original = original;
      _start = start;
      Length = len;
   }

   public T this[int index] {
      get {
         if (index < 0 || index >= Length) throw new IndexOutOfRangeException();
         return _original[_start + index];
      }
   }

   public int Length { get; private set; }

   public IEnumerator<T> GetEnumerator() {
      for (int i = 0; i < Length; i++) {
        yield return _original[_start + i];
      }
   }

   IEnumerator IEnumerable.GetEnumerator() {
      return GetEnumerator();
   }

}

การใช้งาน:

int[] original = { 1, 2, 3, 4, 5 };
SubArray<int> copy = new SubArray<int>(original, 2, 2);

Console.WriteLine(copy.Length); // shows: 2
Console.WriteLine(copy[0]); // shows: 3
foreach (int i in copy) Console.WriteLine(i); // shows 3 and 4

Array.ConstrainedCopy จะทำงาน

public static void ConstrainedCopy (
    Array sourceArray,
    int sourceIndex,
    Array destinationArray,
    int destinationIndex,
    int length
)

ไม่มีวิธีการเดียวที่จะทำสิ่งที่คุณต้องการ คุณจะต้องทำให้วิธีการโคลนพร้อมใช้งานสำหรับชั้นเรียนในอาร์เรย์ของคุณ จากนั้นถ้า LINQ เป็นตัวเลือก:

Foo[] newArray = oldArray.Skip(3).Take(5).Select(item => item.Clone()).ToArray();

class Foo
{
    public Foo Clone()
    {
        return (Foo)MemberwiseClone();
    }
}

วิธีใช้Array.ConstrainedCopy :

int[] ArrayOne = new int[8] {1,2,3,4,5,6,7,8};
int[] ArrayTwo = new int[5];
Array.ConstrainedCopy(ArrayOne, 3, ArrayTwo, 0, 7-3);

ด้านล่างคือโพสต์ดั้งเดิมของฉัน มันจะไม่ทำงาน

คุณสามารถใช้Array.CopyTo :

int[] ArrayOne = new int[8] {1,2,3,4,5,6,7,8};
int[] ArrayTwo = new int[5];
ArrayOne.CopyTo(ArrayTwo,3); //starts copy at index=3 until it reaches end of
                             //either array

เกี่ยวกับสิ่งนี้:

public T[] CloneCopy(T[] array, int startIndex, int endIndex) where T : ICloneable
{
    T[] retArray = new T[endIndex - startIndex];
    for (int i = startIndex; i < endIndex; i++)
    {
        array[i - startIndex] = array[i].Clone();
    }
    return retArray;

}

จากนั้นคุณจะต้องใช้งานอินเทอร์เฟซ ICloneable กับคลาสทั้งหมดที่คุณต้องการใช้ในส่วนนี้ แต่ควรทำเช่นนั้น

ฉันไม่แน่ใจว่ามันลึกแค่ไหน แต่:

MyArray.ToList<TSource>().GetRange(beginningIndex, endIndex).ToArray()

เป็นค่าใช้จ่ายเล็กน้อย แต่อาจตัดวิธีที่ไม่จำเป็นออกไป

C # 8 ได้จัดเตรียมฟีเจอร์ที่เรียกว่าเป็น Range เพื่อรับ subarry ตั้งแต่ต้นจนจบดัชนี คุณสามารถใช้มันได้เช่นนี้

Index i1 = 3; // number 3 from beginning  
Index i2 = ^4; // number 4 from end  
int[] a = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };  
var slice = a[i1..i2]; // { 3, 4, 5 }

เท่าที่การโคลนนิ่งฉันไม่คิดว่าการทำให้เป็นอนุกรมจะเรียกคอนสตรัคเตอร์ของคุณ สิ่งนี้อาจทำลายค่าคงที่ของคลาสหากคุณทำสิ่งที่น่าสนใจใน ctor's

ดูเหมือนว่าการเดิมพันที่ปลอดภัยกว่านั้นคือวิธีโคลนเสมือนที่เรียกใช้ตัวสร้างสำเนา

protected MyDerivedClass(MyDerivedClass myClass) 
{
  ...
}

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

องค์ประกอบของการโคลนในอาร์เรย์ไม่ใช่สิ่งที่สามารถทำได้อย่างเป็นสากล คุณต้องการโคลนนิ่งลึกหรือคัดลอกจากสมาชิกทั้งหมดหรือไม่?

มาเพื่อแนวทาง "ความพยายามที่ดีที่สุด": การโคลนวัตถุโดยใช้ส่วนต่อประสาน ICloneable หรือการทำให้เป็นอันดับแบบไบนารี:

public static class ArrayExtensions
{
  public static T[] SubArray<T>(this T[] array, int index, int length)
  {
    T[] result = new T[length];

    for (int i=index;i<length+index && i<array.Length;i++)
    {
       if (array[i] is ICloneable)
          result[i-index] = (T) ((ICloneable)array[i]).Clone();
       else
          result[i-index] = (T) CloneObject(array[i]);
    }

    return result;
  }

  private static object CloneObject(object obj)
  {
    BinaryFormatter formatter = new BinaryFormatter();

    using (MemoryStream stream = new MemoryStream())
    {
      formatter.Serialize(stream, obj);

      stream.Seek(0,SeekOrigin.Begin);

      return formatter.Deserialize(stream);
    }
  }
}

นี่ไม่ใช่โซลูชันที่สมบูรณ์แบบเพราะไม่มีเพียงสิ่งใดที่สามารถใช้ได้กับวัตถุประเภทใดก็ได้

คุณสามารถเรียนโดย Microsoft:

internal class Set<TElement>
{
    private int[] _buckets;
    private Slot[] _slots;
    private int _count;
    private int _freeList;
    private readonly IEqualityComparer<TElement> _comparer;

    public Set()
        : this(null)
    {
    }

    public Set(IEqualityComparer<TElement> comparer)
    {
        if (comparer == null)
            comparer = EqualityComparer<TElement>.Default;
        _comparer = comparer;
        _buckets = new int[7];
        _slots = new Slot[7];
        _freeList = -1;
    }

    public bool Add(TElement value)
    {
        return !Find(value, true);
    }

    public bool Contains(TElement value)
    {
        return Find(value, false);
    }

    public bool Remove(TElement value)
    {
        var hashCode = InternalGetHashCode(value);
        var index1 = hashCode % _buckets.Length;
        var index2 = -1;
        for (var index3 = _buckets[index1] - 1; index3 >= 0; index3 = _slots[index3].Next)
        {
            if (_slots[index3].HashCode == hashCode && _comparer.Equals(_slots[index3].Value, value))
            {
                if (index2 < 0)
                    _buckets[index1] = _slots[index3].Next + 1;
                else
                    _slots[index2].Next = _slots[index3].Next;
                _slots[index3].HashCode = -1;
                _slots[index3].Value = default(TElement);
                _slots[index3].Next = _freeList;
                _freeList = index3;
                return true;
            }
            index2 = index3;
        }
        return false;
    }

    private bool Find(TElement value, bool add)
    {
        var hashCode = InternalGetHashCode(value);
        for (var index = _buckets[hashCode % _buckets.Length] - 1; index >= 0; index = _slots[index].Next)
        {
            if (_slots[index].HashCode == hashCode && _comparer.Equals(_slots[index].Value, value))
                return true;
        }
        if (add)
        {
            int index1;
            if (_freeList >= 0)
            {
                index1 = _freeList;
                _freeList = _slots[index1].Next;
            }
            else
            {
                if (_count == _slots.Length)
                    Resize();
                index1 = _count;
                ++_count;
            }
            int index2 = hashCode % _buckets.Length;
            _slots[index1].HashCode = hashCode;
            _slots[index1].Value = value;
            _slots[index1].Next = _buckets[index2] - 1;
            _buckets[index2] = index1 + 1;
        }
        return false;
    }

    private void Resize()
    {
        var length = checked(_count * 2 + 1);
        var numArray = new int[length];
        var slotArray = new Slot[length];
        Array.Copy(_slots, 0, slotArray, 0, _count);
        for (var index1 = 0; index1 < _count; ++index1)
        {
            int index2 = slotArray[index1].HashCode % length;
            slotArray[index1].Next = numArray[index2] - 1;
            numArray[index2] = index1 + 1;
        }
        _buckets = numArray;
        _slots = slotArray;
    }

    internal int InternalGetHashCode(TElement value)
    {
        if (value != null)
            return _comparer.GetHashCode(value) & int.MaxValue;
        return 0;
    }

    internal struct Slot
    {
        internal int HashCode;
        internal TElement Value;
        internal int Next;
    }
}

แล้ว

public static T[] GetSub<T>(this T[] first, T[] second)
    {
        var items = IntersectIteratorWithIndex(first, second);
        if (!items.Any()) return new T[] { };


        var index = items.First().Item2;
        var length = first.Count() - index;
        var subArray = new T[length];
        Array.Copy(first, index, subArray, 0, length);
        return subArray;
    }

    private static IEnumerable<Tuple<T, Int32>> IntersectIteratorWithIndex<T>(IEnumerable<T> first, IEnumerable<T> second)
    {
        var firstList = first.ToList();
        var set = new Set<T>();
        foreach (var i in second)
            set.Add(i);
        foreach (var i in firstList)
        {
            if (set.Remove(i))
                yield return new Tuple<T, Int32>(i, firstList.IndexOf(i));
        }
    }

นี่เป็นวิธีที่ดีที่สุดที่ฉันพบเมื่อต้องการทำสิ่งนี้:

private void GetSubArrayThroughArraySegment() {
  int[] array = { 10, 20, 30 };
  ArraySegment<int> segment = new ArraySegment<int>(array,  1, 2);
  Console.WriteLine("-- Array --");
  int[] original = segment.Array;
  foreach (int value in original)
  {
    Console.WriteLine(value);
  }
  Console.WriteLine("-- Offset --");
  Console.WriteLine(segment.Offset);
  Console.WriteLine("-- Count --");
  Console.WriteLine(segment.Count);

  Console.WriteLine("-- Range --");
  for (int i = segment.Offset; i <= segment.Count; i++)
  {
    Console.WriteLine(segment.Array[i]);
  }
}

หวังว่าจะช่วย!

ใช้วิธีการขยาย:

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);

รหัสจาก System.Private.CoreLib.dll:

public static T[] GetSubArray<T>(T[] array, Range range)
{
    if (array == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
    }
    (int Offset, int Length) offsetAndLength = range.GetOffsetAndLength(array.Length);
    int item = offsetAndLength.Offset;
    int item2 = offsetAndLength.Length;
    if (default(T) != null || typeof(T[]) == array.GetType())
    {
        if (item2 == 0)
        {
            return Array.Empty<T>();
        }
        T[] array2 = new T[item2];
        Buffer.Memmove(ref Unsafe.As<byte, T>(ref array2.GetRawSzArrayData()), ref Unsafe.Add(ref Unsafe.As<byte, T>(ref array.GetRawSzArrayData()), item), (uint)item2);
        return array2;
    }
    T[] array3 = (T[])Array.CreateInstance(array.GetType().GetElementType(), item2);
    Array.Copy(array, item, array3, 0, item2);
    return array3;
}

ไม่ตรงตามข้อกำหนดการโคลนของคุณ แต่ดูเหมือนง่ายกว่าคำตอบมากมาย:

Array NewArray = new ArraySegment(oldArray,BeginIndex , int Count).ToArray();

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();
        }