L'altro giorno stavo cercando un modo veloce per eseguire il "Trim" degli elementi di un array di stringhe. Analizzando la classe Array mi sono imbattuto nel metodo Array.ForEach. Questo metodo sembrava proprio fare al caso mio, in quanto permette di eseguire una Action per ogni elemento dell'array, purtroppo però come il classico foreach non permette di modificare gli elementi dell'insieme che stiamo scorrendo.
Sicuro di trovare all'interno della classe Array la soluzione al mio problema ho continuato a cercare fino alla scoperta del metodo Array.ConvertAll. Questo metodo esegue la conversione di tipo fra array permettendo di specificare come parametro la funzione di conversione. Forse non l'ho utilizzato per il motivo per cui è stato sviluppato, ma in definitiva mi ha permesso di ottenere lo scopo con una sola riga di codice (04-05):

string[] myArray = new string[]{ " 23", " 45", " 67 "};
Array.ForEach<string>(myArray, s => Console.Write(s));
// risultato: 23 45 67
myArray = Array.ConvertAll<string, string>(myArray, 
             new Converter<string, string>(s => s.Trim()));
Array.ForEach<string>(myArray, s => Console.Write(s));
// risultato: 234567

Se vogliamo ottenere con LINQ una lista di elementi senza duplicati possiamo utilizzare il metodo Distinct<T>() dell'interfaccia IEnumerable<T> nel seguente modo:

// Prendo da un array di nomi solo quelli che cominciano con M
string[] names = new string[]{ "Andrea", "Marco", "Manuel", "Marco", 
                               "Sara", "Elisa", "Marta" };
var distinctNames = (from name in names
                    where name.StartsWith("M")
                    select name).Distinct<string>();

Tra le novità introdotte dalla versione 3.0 del .NET framework troviamo gli "Initializers" normalmente utilizzati per inizializzare le proprietà di un oggetto direttamente nella chiamata al costruttore, ad esempio:

Person aPerson = new Person(){ Name = "Mario", Surname = "Rossi" };

Analogamente possiamo utilizzare la stessa funzionalità anche per le collezioni e nello specifico vediamo come inizializzare una Hashtable:

Hashtable aCollection = new Hashtable(){ 
                                          { "Key1", "Value1" }, 
                                          { "Key2", "Value2" } 
                                       };

Ci sono diversi modi per concatenare una stringa in C# : con String.Concat,  utilizzando uno StringBuilder, con String.Format oppure ricorrendo all'overloading dell'operatore +. Spinto dalla curiosità di sapere quale di questi modi fosse il più performante ho realizzato un semplice test:

using System;
using System.Text;
using System.Diagnostics;
 
public class Program
{
   static void Main(string[] args)
   {
      Console.WriteLine("String concatenation benchmark");
      Console.WriteLine("------------------------------");
      Console.WriteLine("Plus operator: " + StringPlusOperatorTest());
      Console.WriteLine("String.Format: " + StringFormatTest());
      Console.WriteLine("String.Concat: " + StringConcatTest());
      Console.WriteLine("StringBuilder: " + StringBuilderTest());
      Console.ReadLine();
   }
   
   private static string StringPlusOperatorTest()
   {
      Stopwatch sw = new Stopwatch();
      sw.Start();
      string result = String.Empty;
      for (int i = 0; i < 10000000; i++)
      {
      result = i + " Nel mezzo del cammin di nostra vita, " 
            + "mi ritrovai per una selva oscura" 
            + " ché la diritta via era smarrita.";
      }
      sw.Stop();
      TimeSpan ts = sw.Elapsed;
      return String.Format("{0:00}:{1:00}:{2:00}.{3:00}", 
         ts.Hours, ts.Minutes, ts.Seconds,
         ts.Milliseconds / 10);
   }
 
   private static string StringFormatTest()
   {
      Stopwatch sw = new Stopwatch();
      sw.Start();
      string result = String.Empty;
      for (int i = 0; i < 10000000; i++)
      {
         result = String.Format("{0}{1}{2}{3}", 
            i, " Nel mezzo del cammin di nostra vita, ", 
            "mi ritrovai per una selva oscura", 
            " ché la diritta via era smarrita.");
      }
      sw.Stop();
      TimeSpan ts = sw.Elapsed;
      return String.Format("{0:00}:{1:00}:{2:00}.{3:00}", 
         ts.Hours, ts.Minutes, ts.Seconds,
         ts.Milliseconds / 10);
   }
 
   private static string StringConcatTest()
   {
      Stopwatch sw = new Stopwatch();
      sw.Start();
      string result = String.Empty;
      for (int i = 0; i < 10000000; i++)
      {
         result = String.Concat(i, 
            " Nel mezzo del cammin di nostra vita, ", 
            "mi ritrovai per una selva oscura", 
            " ché la diritta via era smarrita.");
      }
      sw.Stop();
      TimeSpan ts = sw.Elapsed;
      return String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
         ts.Hours, ts.Minutes, ts.Seconds,
         ts.Milliseconds / 10);
   }
 
   private static string StringBuilderTest()
   {
      Stopwatch sw = new Stopwatch();
      sw.Start();
      for (int i = 0; i < 10000000; i++)
      {
         StringBuilder sb = new StringBuilder();
         sb.Append(i);
         sb.Append(" Nel mezzo del cammin di nostra vita, ");
         sb.Append("mi ritrovai per una selva oscura");
         sb.Append(" ché la diritta via era smarrita.");
      }
      sw.Stop();
      TimeSpan ts = sw.Elapsed;
      return String.Format("{0:00}:{1:00}:{2:00}.{3:00}", 
         ts.Hours, ts.Minutes, ts.Seconds,
         ts.Milliseconds / 10);
   }

Il test consiste nel concatenare tre stringhe più un contatore. Data la semplicità dell'operazione per avere dei risultati misurabili ho dovuto inserire l'operazione in un ciclo for. Dai risultati visibili nell'immagine qui sotto si può notare come l'operatore + sia il più veloce seguito dal metodo String.Concat e a grande distanza dagli altri due metodi...

 

Se però consideriamo una concatenazione con più stringhe (42 per la precisione) otteniamo i risultati visibili nell'immagine sottostante. L'operatore + è ancora il migliore, ma il metodo String.Concat peggiora notevolemente forse per il numero cospicuo di parametri.

 

Per quanto possa essere misurabile e percepita dall'utente la differenza di performance questo test conferma una banalità, usare String.Concat per la concatenazione di stringhe e String.Format per la formattazione. :-)