c# - initialize - run ienumerator

¿Cuál es la mejor manera de convertir un IEnumerator a un IEnumerator genérico?

Question

Estoy escribiendo un ConfigurationElementCollection personalizado para un ConfigurationHandler personalizado en C # .NET 3.5 y deseo exponer el IEnumerator como un IEnumerator genérico.

¿Cuál sería la mejor manera de lograr esto?

Actualmente estoy usando el código:

public new IEnumerator<GenericObject> GetEnumerator() { var list = new List(); var baseEnum = base.GetEnumerator(); while(baseEnum.MoveNext()) { var obj = baseEnum.Current as GenericObject; if (obj != null) list.Add(obj); } return list.GetEnumerator(); }

Aclamaciones

Answer 1

Esto funciona para mi

IEnumerator<DataColumn> columnEnumerator = dt.Columns.Cast<DataColumn>().GetEnumerator();

Answer 2

Me encontré con el mismo problema de desbordamiento de pila mencionado en algunos de los comentarios. En mi caso se debió al hecho de que la llamada a GetEnumerator tenía que ser a la base. De lo contrario, obtendrías un bucle dentro de tu propia redefinición de GetEnumerator.

Este es el código que estaba tirando el desbordamiento de pila. El uso de la instrucción foreach llama a la misma función GetEnumerator que estoy intentando sobrecargar:

public new IEnumerator<T> GetEnumerator()
{
foreach (T type in this)
{
yield return type;
}
}

Terminé con una versión simplificada de la publicación original, ya que no es necesario utilizar un titular de la Lista.

public class ElementCollection<T> : ConfigurationElementCollection, IList<T>
...
public new IEnumerator<T> GetEnumerator()
{
var baseEnum = base.GetEnumerator();
while (baseEnum.MoveNext())
{
yield return baseEnum.Current as T;
}
}
...
}

Answer 3

Puede usar OfType<T> y Cast<T> .

public static IEnumerable Digits()
{
return new[]{1, 15, 68, 1235, 12390, 1239};
}
var enumerable = Digits().OfType<int>();
foreach (var item in enumerable)
// var is here an int. Without the OfType<int(), it would be an object
Console.WriteLine(i);

Para obtener un IEnumerator<T> lugar de un IEnumerable<T> , solo puede hacer una llamada a GetEnumerator()

var enumerator = Digits().OfType<int>().GetEnumerator();

Answer 4

IEnumerable<T> ya deriva de IEnumerable por lo que no es necesario realizar ninguna conversión. Simplemente puedes lanzarle ... bueno, en realidad está implícito, no es necesario lanzar.

IEnumerable<T> enumerable = GetGenericFromSomewhere();
IEnumerable sadOldEnumerable = enumerable;
return sadOldEnumerable.GetEnumerator();

Ir al revés no es mucho más difícil con LINQ:

var fancyEnumerable = list.OfType<GenericObject>();
return fancyEnumerable.GetEnumerator();

Answer 5

No creo que haya nada en el marco, pero podría escribir uno fácilmente:

IEnumerator<T> Cast<T>(IEnumerator iterator)
{
while (iterator.MoveNext())
{
yield return (T) iterator.Current;
}
}

Es tentador simplemente llamar a Enumerable.Cast<T> desde LINQ y luego llamar a GetEnumerator() en el resultado, pero si su clase ya implementa IEnumerable<T> y T es un tipo de valor, que actúa como un no-op, por lo que GetEnumerator() llamada a GetEnumerator() repite y lanza una excepción Exception . Es seguro usar return foo.Cast<T>.GetEnumerator(); cuando foo es definitivamente un objeto diferente (que no se delega a este) pero de lo contrario, probablemente sea mejor usar el código de arriba.