получение универсального перечислителя из массива
-
13-09-2019 - |
Вопрос
В C #, как получить универсальный перечислитель из заданного массива?
В приведенном ниже коде, MyArray
представляет собой массив MyType
Объекты.Я хотел бы получить MyIEnumerator
показанным способом,
но, похоже, я получаю пустой перечислитель (хотя я подтвердил это MyArray.Length > 0
).
MyType [ ] MyArray = ... ;
IEnumerator<MyType> MyIEnumerator
= ( MyArray.GetEnumerator() as IEnumerator<MyType> ) ;
Решение
Работает на версии 2.0+:
((IEnumerable<MyType>)myArray).GetEnumerator()
Работает на 3.5+ (навороченный LINQy, немного менее эффективный):
myArray.Cast<MyType>().GetEnumerator() // returns IEnumerator<MyType>
Другие советы
Вы можете сами решить, является ли приведение достаточно уродливым, чтобы оправдать посторонний вызов библиотеки:
int[] arr;
IEnumerator<int> Get1()
{
return ((IEnumerable<int>)arr).GetEnumerator(); // <-- 1 non-local call
// L_0001: ldarg.0
// L_0002: ldfld int32[] foo::arr
// L_0007: castclass [mscorlib]System.Collections.Generic.IEnumerable`1<int32>
// L_000c: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> [mscorlib]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
// L_0011: stloc.0
}
IEnumerator<int> Get2()
{
return arr.AsEnumerable().GetEnumerator(); // <-- 2 non-local calls
// L_0001: ldarg.0
// L_0002: ldfld int32[] foo::arr
// L_0007: call class [mscorlib]System.Collections.Generic.IEnumerable`1<!!0> [System.Core]System.Linq.Enumerable::AsEnumerable<int32>(class [mscorlib]System.Collections.Generic.IEnumerable`1<!!0>)
// L_000c: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> [mscorlib]System.Collections.Generic.IEnumerable`1<int32>::GetEnumerator()
// L_0011: stloc.0
}
И для полноты картины следует также отметить, что следующее неверно - и приведет к сбою во время выполнения - потому что T[]
выбирает тот не-общий IEnumerable
интерфейс по умолчанию (т. е.неявная) реализация GetEnumerator()
.
IEnumerator<int> NoGet() // error - do not use
{
return (IEnumerator<int>)arr.GetEnumerator();
// L_0001: ldarg.0
// L_0002: ldfld int32[] foo::arr
// L_0007: callvirt instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Array::GetEnumerator()
// L_000c: castclass [mscorlib]System.Collections.Generic.IEnumerator`1<int32>
// L_0011: stloc.0
}
Загадка в том, почему этого не происходит SZGenericArrayEnumerator<T>
наследовать от SZArrayEnumerator
--внутренний класс, который в настоящее время помечен как "запечатанный" - поскольку это позволило бы возвращать (ковариантный) общий перечислитель по умолчанию?
Поскольку мне не нравится кастинг, небольшое обновление:
your_array.AsEnumerable().GetEnumerator();
Чтобы сделать его как можно более чистым, я хотел бы позволить компилятору выполнять всю работу.Приведений нет (так что на самом деле это типобезопасно).Сторонние библиотеки (System.Linq) не используются (нет накладных расходов во время выполнения).
public static IEnumerable<T> GetEnumerable<T>(this T[] arr)
{
return arr;
}
// И использовать код:
String[] arr = new String[0];
arr.GetEnumerable().GetEnumerator()
Это использует преимущества некоторой магии компилятора, которая поддерживает все в чистоте.
Другой момент, который следует отметить, заключается в том, что мой ответ - это единственный ответ, который будет выполнять проверку во время компиляции.
Для любого из других решений, если тип "arr" изменится, вызывающий код будет скомпилирован и завершится сбоем во время выполнения, что приведет к ошибке во время выполнения.
Мой ответ приведет к тому, что код не будет компилироваться, и, следовательно, у меня будет меньше шансов обнаружить ошибку в моем коде, поскольку это будет сигнализировать мне, что я использую неправильный тип.
YourArray.OfType().GetEnumerator();
может работать немного лучше, поскольку он должен только проверять тип, а не приводить.
MyType[] arr = { new MyType(), new MyType(), new MyType() };
IEnumerable<MyType> enumerable = arr;
IEnumerator<MyType> en = enumerable.GetEnumerator();
foreach (MyType item in enumerable)
{
}
Что вы, конечно, можете сделать, так это просто реализовать свой собственный универсальный перечислитель для массивов.
using System.Collections;
using System.Collections.Generic;
namespace SomeNamespace
{
public class ArrayEnumerator<T> : IEnumerator<T>
{
public ArrayEnumerator(T[] arr)
{
collection = arr;
length = arr.Length;
}
private readonly T[] collection;
private int index = -1;
private readonly int length;
public T Current { get { return collection[index]; } }
object IEnumerator.Current { get { return Current; } }
public bool MoveNext() { index++; return index < length; }
public void Reset() { index = -1; }
public void Dispose() {/* Nothing to dispose. */}
}
}
Это более или менее равно .ЧИСТАЯ реализация SZGenericArrayEnumerator<T> как упоминал Гленн Слайден.Конечно, вы должны делать это только в тех случаях, когда это стоит затраченных усилий.В большинстве случаев это не так.