Come creare un elenco <T> da una stringa separata da virgole?

Question

Data la variabile

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

Esiste un modo per convertirlo in un elenco senza fare qualcosa di simile a

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

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

Answer 1

Per creare la lista da zero, utilizzare LINQ:

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

Se hai già l'oggetto lista, omettere la chiamata ToList() e utilizzare AddRange:

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

Se alcune voci la stringa non può essere interi, è possibile utilizzare TryParse: metodo che evita temps

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

Un ultimo (più lento)/TryParse ma salta voci non valide è quello di utilizzare Regex:

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

Tuttavia, questo può gettare se uno dei vostri voci trabocca int (999.999.999.999).

Answer 2

utilizzando LINQ:

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

O direttamente:

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

Inoltre, per evitare che il compilatore di generare esplicitamente lambda (largamente ridondante), considerare:

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

(suggerimento: micro-ottimizzazione.)

C'è anche TryParse che dovrebbe essere usato al posto di Parse (solo) se l'input non valido è possibile e deve essere gestito in silenzio. Tuttavia, altri hanno pubblicato soluzioni usando TryParse quindi certamente non lo farò. Ricorda che non devi duplicare il calcolo.

Answer 3

Questo dovrebbe fare il trucco:

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

Se l'elenco può contenere altri dati oltre a numeri interi, una chiamata TryParse dovrebbe essere inclusa. Vedi la risposta accettata.

Answer 4

Un problema a portata di mano qui è il modo in cui tratteremo i valori che non sono numeri interi (assumiamo che ne otterremo alcuni che non sono numeri interi). Un'idea potrebbe essere usare semplicemente una regex:

^- [0-9] + $

Ora, potremmo combinare tutto questo con (come mostrato nell'esempio di Konrad):?

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

Questo dovrebbe fare il lavoro.

Answer 5

o comprendente TryParse come nel tuo esempio:

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

Answer 6

per abbinare la richiesta in termini di prestazioni e di comportamento, che dovrebbe fare la stessa cosa e non andare fuori espressioni regolari doign o non fare il '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(); 

Ma mentre corretto, che è abbastanza brutto: D

Prendendo in prestito da un accenno di commento di 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();