C# è disponibile un oneliner foreach?

Question

Voglio solo sapere se c'è un foreach oneliner in C#, come il se oneliner (exp) ? then : else.

Answer 1

Se hai a che fare con una serie quindi è possibile utilizzare il metodo statico ForEach built-in:

Array.ForEach(yourArray, x => Console.WriteLine(x)); 

Se hai a che fare con una List<T> quindi è possibile utilizzare il metodo built-in ForEach esempio :

yourList.ForEach(x => Console.WriteLine(x)); 

Non c'è niente di built-in che ti lavorare contro ogni arbitraria sequenza IEnumerable<T>, ma è abbastanza facile da rotolare il proprio metodo di estensione se si sente che hai bisogno:

yourSequence.ForEach(x => Console.WriteLine(x)); 

// ... 

public static class EnumerableExtensions 
{ 
    public static void ForEach<T>(this IEnumerable<T> source, Action<T> action) 
    { 
     if (source == null) throw new ArgumentNullException("source"); 
     if (action == null) throw new ArgumentNullException("action"); 

     foreach (T item in source) 
     { 
      action(item); 
     } 
    } 
} 

Answer 2

List.ForEach Method

Answer 3

foreach linea battute potrebbero essere ottenuti con metodi di estensione LINQ. Per esempio:

invece di:

var result = new List<string>(); 
foreach (var item in someCollection) 
{ 
    result.Add(item.Title); 
} 

si potrebbe:

var result = someCollection.Select(x => x.Title).ToList(); 

Answer 4

Certo, si può usare qualcosa come List<>::ForEach:

List<String> s = new List<string>(); 
    s.Add("These"); 
    s.Add("Is"); 
    s.Add("Some"); 
    s.Add("Data"); 
    s.ForEach(_string => Console.WriteLine(_string)); 

Answer 5

La differenza principale tra se e l'operatore ? è che se è una dichiarazione mentre "?" produce un'espressione. Cioè Non si può fare questo:

 

var _ = (exp) ? then : else; // ok 
 

ma non questa:

 

var _ = if (exp) { then; } else { else; }; // error 
 

Quindi, se siete alla ricerca di qualcosa di simile espressione foreach non c'è nessun tipo di .NET si può naturalmente tornare ad eccezione di vuoto, ma non ci sono valori di tipo void, in modo da poter ugualmente solo scrivere:

 

foreach (var item in collection) process(item); 
 

In molti linguaggi funzionali un tipo di unità viene utilizzato al posto del vuoto che è di tipo con un solo valore. È possibile emulare questa in .NET e creare il proprio espressione foreach:

 

    class Unit 
    { 
     public override bool Equals(object obj) 
     { 
      return true; 
     } 

     public override int GetHashCode() 
     { 
      return 0; 
     } 
    } 

    public static class EnumerableEx 
    { 
     public static Unit ForEach<TSource>(
      this IEnumerable<TSource> source, 
      Action<TSource> action) 
     { 
      foreach (var item in source) 
      { 
       action(item); 
      } 

      return new Unit(); 
     } 
    } 
 

V'è però praticamente non esiste alcun caso d'uso di tali espressioni.