C# 如何将一系列阵列元素克隆到新阵列？
我有一个由10个元素组成的数组X。我想创建一个新数组，包含从X开始的从索引3到索引7的所有元素。当然，我可以很容易地编写一个循环，这将为我做到这一点，但我想保持我的代码尽可能干净。有没有一种C#语言的方法可以帮我做到这一点 类似于（伪代码）：C# 如何将一系列阵列元素克隆到新阵列？,c#,arrays,.net,clone,deep-copy,C#,Arrays,.net,Clone,Deep Copy,我有一个由10个元素组成的数组X。我想创建一个新数组，包含从X开始的从索引3到索引7的所有元素。当然，我可以很容易地编写一个循环，这将为我做到这一点，但我想保持我的代码尽可能干净。有没有一种C#语言的方法可以帮我做到这一点 类似于（伪代码）： 数组。复制不符合我的需要。我需要新阵列中的项目是克隆的Array.copy只是一个C风格的memcpy等价物，这不是我想要的。在创建新数组后，可以使用它复制到新数组中，但我认为没有一种方法可以创建新数组并复制一系列元素 如果您使用的是.NET 3.5，则可
数组。复制Array.copymemcpyvar newArray = array.Skip(3).Take(5).ToArray();
有关更具体情况的选项，请参见类似问题。您可以将其添加为扩展方法：
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}
}
公共静态T[]子数组（此T[]数据，int索引，int长度）
{
T[]结果=新的T[长度]；
复制（数据、索引、结果、0、长度）；
返回结果；
}
静态void Main（）
{
int[]数据={0,1,2,3,4,5,6,7,8,9}；
int[]sub=data.SubArray（3,4）；//包含{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);
}
}
public static T[]subraydepclone（此T[]数据，int索引，int长度）
{
T[]arrCopy=新的T[长度]；
Array.Copy（数据、索引、arrCopy、0、长度）；
使用（MemoryStream ms=new MemoryStream（））
{
var bf=新的二进制格式化程序（）；
bf.序列化（ms，arrCopy）；
ms.Position=0；
返回（T[]）bf.反序列化（ms）；
}
}
[serializable]ISerializableXmlSerializerDataContractSerializer请注意，如果没有序列化，深度克隆是很棘手的；特别是，
ICloneablepublic static void ConstrainedCopy (
Array sourceArray,
int sourceIndex,
Array destinationArray,
int destinationIndex,
int length
)
我认为您正在寻找的代码是：
Array.Copy（oldArray、0、newArray、BeginIndex、EndIndex-BeginIndex）作为复制数据的替代方法，您可以制作一个包装器，使您能够访问原始数组的一部分，就像它是数组部分的副本一样。这样做的好处是不会在内存中获得数据的另一个副本，缺点是在访问数据时会有轻微的开销
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();
}
}
公共类子数组：IEnumerable{
私人T[]_原件；
私人互联网启动；
公共子阵列（T[]原始，int开始，int len）{
_原件=原件；
_开始=开始；
长度=长度；
}
公共T此[int索引]{
得到{
如果（索引<0 | |索引>=Length）抛出新的索引AutoFrangeException（）；
返回原始[_开始+索引]；
}
}
公共整数长度{get；私有集；}
公共IEnumerator GetEnumerator（）{
for（int i=0；iint[] 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
int[]original={1,2,3,4,5}；
子阵列副本=新的子阵列（原始，2，2）；
Console.WriteLine（copy.Length）；//节目：2
Console.WriteLine（复制[0]）；//节目：3
foreach（复制中的int i）控制台。WriteLine（i）；//图3和图4
。选择将阵列成员投影到其克隆。
例如，如果您的元素实现了IClonable
，您可以执行以下操作：
var newArray = array.Skip(3).Take(5).Select(eachElement => eachElement.Clone()).ToArray();
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 }
注意：此解决方案需要.NET Framework 3.5。基于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;
}
public static T[]CloneSubArray（此T[]数据，int索引，int长度）
T:ICloneable在哪里
{
T[]结果=新的T[长度]；
for（int i=0；i
如果实现iClonable太像是一项艰苦的工作，那么就用它来完成所需的繁重工作
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；
公共静态T[]子阵列(
这T[]数据，整数索引，整数长度）
{
T[]结果=新的T[长度]；
for（int i=0；i
请注意，OX.Copyable实现适用于以下任何一种情况：
但是，要使自动复制正常工作，必须包含以下语句之一，例如：
- 其类型必须具有无参数构造函数，或
- 它必须是可复制的，或者
- 必须为其类型注册IInstanceProvider
因此，这应该涵盖几乎所有的情况。如果要克隆子图中包含db连接或文件/流句柄等内容的对象，显然会有问题，但对于任何通用的深度复制都是如此
如果您想使用其他深度复制方法，那么我建议您不要尝试编写自己的方法。没有一个方法可以满足您的需要。您需要为阵列中的类提供一个克隆方法。然后，如果LINQ是一个选项：
Foo[] newArray = oldArray.Skip(3).Take(5).Select(item => item.Clone()).ToArray();
class Foo
{
public Foo Clone()
{
return (Foo)MemberwiseClone();
}
}
克隆数组中的元素不是通用的方法。您想要深度克隆还是所有成员的简单副本
让我们采用“尽力而为”的方法：使用iClonable接口或二进制文件克隆对象
Foo[] newArray = oldArray.Skip(3).Take(5).Select(item => item.Clone()).ToArray();
class Foo
{
public Foo Clone()
{
return (Foo)MemberwiseClone();
}
}
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);
}
}
}
protected MyDerivedClass(MyDerivedClass myClass)
{
...
}
public override MyBaseClass Clone()
{
return new MyDerivedClass(this);
}
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);
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;
}
// 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();
string[] arr = { "Parrot" , "Snake" ,"Rabbit" , "Dog" , "cat" };
arr = arr.ToList().GetRange(0, arr.Length -1).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();
}
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]);
}
}
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 }
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);
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();
int[] list = {1, 2, 3, 4, 5, 6};
var list2 = list[2..5].Clone() as int[]; // 3, 4, 5
var list3 = list[..5].Clone() as int[]; // 1, 2, 3, 4, 5
var list4 = list[^4..^0].Clone() as int[]; // reverse index