Cómo crear una lista <T> a partir de una cadena separada por comas?

Question

Teniendo en cuenta la variable

string ids = Request.QueryString["ids"]; // "1,2,3,4,5"; 

¿Hay alguna manera de convertirlo en una lista sin hacer algo como

List<int> myList = new List<int>(); 

foreach (string id in ids.Split(',')) 
{ 
    if (int.TryParse(id)) 
    { 
     myList.Add(Convert.ToInt32(id)); 
    } 
} 

Answer 1

para crear la lista desde cero, utilizar LINQ:

ids.Split(',').Select(i => int.Parse(i)).ToList(); 

Si ya tiene el objeto de lista, omita la llamada ToList() y utilizar AddRange:

myList.AddRange(ids.Split(',').Select(i => int.Parse(i))); 

Si algunas entradas en la cadena puede no ser enteros, puede utilizar TryParse:

método

int temp; 
var myList = ids.Split(',') 
    .Select(s => new { P = int.TryParse(s, out temp), I = temp }) 
    .Where(x => x.P) 
    .Select(x => x.I) 
    .ToList(); 

Una última (más lento) que evita temps/TryParse pero se salta las entradas no válidas es el uso de expresiones regulares:

var myList = Regex.Matches(ids, "[0-9]+").Cast<Match>().SelectMany(m => m.Groups.Cast<Group>()).Select(g => int.Parse(g.Value)); 

Sin embargo, esto puede tirar si una de las entradas desborda int (999999999999).

Answer 2

Usando LINQ:

myList.AddRange(ids.Split(',').Select(s => int.Parse(s)); 

O directamente:

var myList = ids.Split(',').Select(s => int.Parse(s)); 

Además, para evitar que el compilador generar explícitamente la lambda (en gran medida redundante), considere:

var myList = ids.Split(',').Select((Func<string, int>)int.Parse); 

(Pista: micro-optimización.)

También hay TryParse que debe ser usado en lugar de Parse (sólo) si la entrada no válida es posible y debe manejarse en silencio. Sin embargo, otros han publicado soluciones usando TryParse así que ciertamente no lo haré. Solo tenga en cuenta que no debe duplicar el cálculo.

Answer 3

Esto debe hacer el truco:

myList.Split(',').Select(s => Convert.ToInt32(s)).ToList(); 

Si la lista puede contener otros datos además de los números enteros, una llamada TryParse deben ser incluidos. Ver la respuesta aceptada.

Answer 4

Un problema que tenemos aquí es cómo vamos a tratar con valores que no son enteros (supongamos que obtendremos algunos que no son enteros). Una idea podría ser simplemente usar una expresión regular:

^- [0-9] + $

Ahora, podemos combinar todo esto con (como se muestra en el ejemplo de Konrad):?

var myList = ids.Split(',').Where(s => Regex.IsMatch(s, "^-?[0-9]$")).Select(s => Convert.ToInt32(s)).ToList(); 

Eso debería hacer el trabajo.

Answer 5

O incluyendo TryParse como en su ejemplo:

var res = ids.Split(',').Where(x => { int tmp; return int.TryParse(x, out tmp); }).Select(x => int.Parse(x)).ToList(); 

Answer 6

para que coincida con la petición formulada en términos de características y el comportamiento de rendimiento, se debe hacer lo mismo y no ir fuera de expresiones regulares doign o no hacer el 'TryParse' : -

ds.Split(',') 
    .Select(i => { 
    int value; 
    bool valid = int.TryParse(out value); 
    return new {valid, value} 
    }) 
    .Where(r=>r.valid) 
    .Select(r=>r.value) 
    .ToList(); 

Sin embargo, aunque correcta, eso es bastante feo: D

Préstamos de una pista en el comentario de Jason: -

ds.Split(',') 
    .Select(i => { 
    int value; 
    bool valid = int.TryParse(out value); 
    return valid ? new int?(value) : null; 
    }) 
    .Where(r=>r != null) 
    .Select(r=>r.Value) 
    .ToList(); 

O

static class Convert 
{ 
    public static Int32? ConvertNullable(this string s) 
    { 
    int value; 
    bool valid = int.TryParse(out value); 
    return valid ? new int?(value) : null; 
    } 
} 

ds.Split(',') 
    .Select(s => Convert.ConvertNullable(s)) 
    .Where(r=>r != null) 
    .Select(r=>r.Value) 
    .ToList();