Varolan bir diziden alt dizi alma

10 elemanlık bir dizi X var. X dizin 3'te başlayan ve dizin 7 biten tüm öğeleri içeren yeni bir dizi oluşturmak istiyorum. Eminim kolayca benim için yapacak bir döngü yazabilirsiniz ama kodumu olabildiğince temiz tutmak istiyorum . C # benim için yapabileceğiniz bir yöntem var mı?

Gibi bir şey (sözde kod):

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

Array.Copyihtiyaçlarımı karşılamıyor . Klon olmak için yeni dizideki öğeleri gerekir. Array.copysadece bir C-Style memcpyeşdeğeri, aradığım şey bu değil.

Bir uzantı yöntemi olarak ekleyebilirsiniz:

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}
}

Güncelleme yeniden klonlama (orijinal soruda belirgin değildi). Eğer varsa gerçekten derin bir klon istiyorum; gibi bir şey:

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

Bu, nesnelerin serileştirilebilir ( [Serializable]veya ISerializable) olmasını gerektirir . Uygun şekilde diğer herhangi bir serileştiricinin yerine geçebilirsiniz - XmlSerializer,, protobuf DataContractSerializer-net, vb.

Derin klonun serileştirme olmadan zor olduğunu unutmayın; özellikle, ICloneableçoğu durumda güvenmek zordur.

Array.Copy(...)Oluşturduktan sonra yeni diziye kopyalamak için kullanabilirsiniz , ancak yeni diziyi oluşturan ve bir dizi öğeyi kopyalayan bir yöntem olduğunu düşünmüyorum .

Eğer .NET 3.5 kullanıyorsanız, olabilir LINQ kullanmak:

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

ancak bu biraz daha az verimli olacaktır.

Daha spesifik durumlar için seçenekler için benzer bir soruya verilen bu cevaba bakınız .

Kullanmayı düşündünüz mü ArraySegment?

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

Sadece referansları kopyalamakla kalmayıp Klonlama yapmak istediğinizi görüyorum. Bu durumda, .Selectdizi üyelerini klonlarına yansıtmak için kullanabilirsiniz . Örneğin, öğeleriniz uygulandığında IClonableböyle bir şey yapabilirsiniz:

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

Not: Bu çözüm için .NET Framework 3.5 gerekir.

Aşağıdaki kod tek bir satırda bunu yapar:

// 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'de yeni bir sunduk Rangeve Indextürünü

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'ın cevabına dayanmak ama istenen klonlama davranışını eklemek

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

Ve eğer ICloneable uygulamak zor bir iş gibi ise, Håvard Stranden'in Copdable kütüphanesini kullanarak ağır kaldırma yapmak için yansıtıcı bir çalışma .

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 uygulamasının aşağıdakilerden herhangi biriyle çalıştığını unutmayın:

Ancak otomatik kopyanın çalışması için aşağıdaki ifadelerden birinin örneğin tutulması gerekir:

• Türü parametresiz bir kurucuya sahip olmalı veya
• Bir Copdable olmalı veya
• Türü için bir IInstanceProvider kayıtlı olması gerekir.

Yani bu neredeyse her durumunuzu kapsamalıdır. Alt grafiğin db bağlantıları veya dosya / akış tutamaçları gibi şeyler içerdiği nesneleri klonluyorsanız, açık bir şekilde sorunlarınız var, ancak herhangi bir genelleştirilmiş derin kopya için doğru.

Başka derin kopya yaklaşımını kullanmak istiyorsanız, bu makalede birkaç tane listelenir, bu yüzden kendi yazmaya çalışmamanızı öneririm.

Bunu oldukça kolay bir şekilde yapabilirsiniz;

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

Aradığınız kod olduğunu düşünüyorum:

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

Verileri kopyalamaya alternatif olarak, orijinal dizinin bir bölümüne, dizinin bir parçasıymış gibi erişmenizi sağlayan bir sarıcı yapabilirsiniz. Avantajı, bellekteki verilerin başka bir kopyasını almamanız ve verilere erişirken dezavantaj hafif bir ek yük olmasıdır.

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

}

Kullanımı:

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 çalışır.

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

İstediğinizi yapacak tek bir yöntem yoktur. Dizinizdeki sınıf için bir klonlama yöntemi kullanmanız gerekir. Sonra, LINQ bir seçenek ise:

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

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

Array.ConstrainedCopy kullanmaya ne dersiniz :

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

Aşağıda benim orijinal yazım. Çalışmayacak

Array.CopyTo kullanabilirsiniz :

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

Buna ne dersin:

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;

}

Daha sonra bunu kullanmanız gereken tüm sınıflara ICloneable arabirimini uygulamanız gerekir, ancak bunu yapmanız gerekir.

Gerçekten ne kadar derin olduğundan emin değilim, ama:

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

Biraz ek yük, ancak gereksiz bir yöntemi kesebilir.

C # 8, başlangıçtan bitişe kadar alt diziyi almak için Aralık olarak adlandırılan bir özellik sağlamıştır. bu şekilde kullanabilirsiniz.

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 }

Klonlama ile ilgili olarak, serileştirmenin inşaatçılarınızı çağırdığını sanmıyorum. Eğer ctor'da ilginç şeyler yapıyorsanız bu sınıf değişmezlerini kırabilir.

Daha güvenli bahis kopya kurucuları olarak adlandırılan sanal klon yöntemleri gibi görünüyor.

protected MyDerivedClass(MyDerivedClass myClass) 
{
  ...
}

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

Bir dizideki öğeleri klonlamak evrensel bir şekilde yapılabilecek bir şey değildir. Derin klonlama mı yoksa tüm üyelerin basit bir kopyası mı istiyorsunuz?

"En iyi çaba" yaklaşımına geçelim: ICloneable arabirimini veya ikili serileştirmeyi kullanarak nesneleri klonlama:

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

Bu mükemmel bir çözüm değildir, çünkü herhangi bir nesne türü için işe yarayacak hiçbir şey yoktur.

Microsoft tarafından yapılan dersi alabilirsiniz:

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

ve sonra

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

Bunu yapmanın en iyi yolu budur:

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

Umarım yardımcı olur!

genişletme yöntemini kullanın:

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

ve kullanabilirsiniz

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

System.Private.CoreLib.dll kodu:

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

Klonlama gereksiniminizi karşılamıyor, ancak yapılacak birçok yanıttan daha basit görünüyor:

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