sabato 15 dicembre 2012

Easy Parallelism in .NET ? PLINQ !

come parallelizzare facilmente delle ricerche all'interno di una lista ? usando PLinQ cos'è ?
immaginate una ricerca su una lista semplice cosi come di seguito :

var customers = new[] {
 new Customer { ID = 1,  FirstName = "Sandeep"  , LastName = "Ramani" },
 new Customer { ID = 2,  FirstName = "Dharmik"  , LastName = "Chotaliya" },
 new Customer { ID = 3,  FirstName = "Nisar"    ,  LastName = "Kalia" } ,
 new Customer { ID = 4,  FirstName = "Ravi"     , LastName = "Mapara" } ,
 new Customer { ID = 5,  FirstName = "Hardik"   , LastName = "Mistry" }
 new Customer { ID = 6,  FirstName = "Sandy"    , LastName = "Ramani" },
 new Customer { ID = 7,  FirstName = "Jigar"    , LastName = "Shah" },
 new Customer { ID = 8,  FirstName = "Kaushal"  , LastName = "Parik" } ,
 new Customer { ID = 9,  FirstName = "Abhishek" , LastName = "Swarnker" } ,
 new Customer { ID = 10, FirstName = "Sanket"   , LastName = "Patel" }
 new Customer { ID = 11, FirstName = "Dinesh"   , LastName = "Prajapati" },
 new Customer { ID = 12, FirstName = "Jayesh"   , LastName = "Patel" },
 new Customer { ID = 13, FirstName = "Nimesh"   , LastName = "Mishra" } ,
 new Customer { ID = 14, FirstName = "Shiva"    , LastName = "Reddy" } ,
 new Customer { ID = 15, FirstName = "Jasmin"   , LastName = "Malviya" }
 new Customer { ID = 16, FirstName = "Haresh"   , LastName = "Bhanderi" },
 new Customer { ID = 17, FirstName = "Ankit"    , LastName = "Ramani" },
 new Customer { ID = 18, FirstName = "Sanket"   , LastName = "Shah" } ,
 new Customer { ID = 19, FirstName = "Amit"     , LastName = "Shah" } ,
 new Customer { ID = 20, FirstName = "Nilesh"   , LastName = "Soni" }       };

  List<Customer> result = new List<Customer>();
 foreach( Customer c in customers )
  if ( c.FirstName.StartWith("San") )
   result.add(c) ;
Come parallalelizzare semplicemente ed in maniera efficente questa ricerca ? 
semplicemente usando PLinQ e sostituendo il ciclo in questo modo : 


var results = from c in customers.AsParallel()
  where c.FirstName.StartsWith("San")
  select c;


Con la semplice aggiunta del metodo di estensione AsParallel(), il runtime .NET automaticamente parallelizza l'operazione in più nuclei. 

Limitazioni :
PLINQ funziona solo contro collezioni locali. Questo significa che se si sta utilizzando il provider LINQ sopra dati remoti, ad esempio LINQ to SQL o ADO.NET Entity Framework, allora non sei fortunato per questa versione. Poiché PLINQ divide la collection in più partizioni e li esegue in parallelo, i risultati che si otterrebbero da una query PLINQ non sarà nello stesso ordine dei risultati che si otterrebbero da una query LINQ eseguita o da un approccio tradizionale.

 Tuttavia, si può aggirare questo introducendo il metodo AsOrdered() nella tua query, che costringerà a un ordinamento specifico nei vostri risultati.




var results = from c in customers.AsParallel().AsOrdered()
  where c.FirstName.StartsWith("San")
  select c;



Tieni presente, tuttavia, che inserendo AsOrdered()per insiemi di grandi dimensioni, puoi perdere in termini di performance i guadagni di parallelizzazione ottenuti.

sabato 8 dicembre 2012

c# cross-platform Mobile tool 4 Android & iOS



 VSNomad Cool C# cross-platform Mobile tool 4 Android & iOS
http://www.youtube.com/watch?feature=player_embedded&v=W8Gto7JkCBk#!


Server VPS or Dedicated ? find the difference !!


Avete un pò le idee confuse riguardo la differenza tra un VPS – Server Virtuale ed un Server Dedicato? Bene, non preoccupatevi, oggi cercherò di chiarire le differenze e mettere fine ai vostri dubbi.

VPS – Server Virtuale (Virtual Private Server)

Un VPS e’ un server virtuale in funzione su un server fisico, le cui risorse sono divise tra piu’ utenti. Questo avviene grazie alla suddivisione di  un server in più macchine virtuali, separate ed isolate tra loro tramite apposite applicazioni, dando quindi ai propri clienti la possibilità di configurare e gestire in piena autonomia il proprio VPS.
E’ possibile scegliere il sistema operativo, le applicazioni da installare, ed è altamente personalizzabile.
E’ un’ottima forma di hosting dedicato, consigliata a chi possiede un sito di grandi dimensioni e/o di grande traffico, o chi vuole o deve gestire più siti contemporaneamente. E’ un hosting dedicato che grazie alla virtualizzazione permette di usufruire di ottime potenzialità a prezzi veramente convenienti.
Mi raccomando, prestate sempre attenzione ai prezzi che trovate in giro per la rete, ci sono una miriade di servizi ed offerte nel settore, più o meno convenienti. Se avete esperienze limitate con la gestione di un server, affidatevi ad un servizio “managed“.

Server Dedicato

E’ sicuramente la forma di hosting più personalizzabile e costosa che c’è, consigliata per siti estremamente trafficati e con un alto consumo di risorse. Si avrà la possibilità di gestire e configurare a proprio piacimento un intero server, e di utilizzare l’hardware noleggiato per il servizio che preferiamo. Numerosissime le offerte per server dedicati presenti in rete, con la possibilità di scegliere tra processori AMD e Intel di ultima generazione, scegliere quanta memoria ram acquistare, hard disk, etc.
Come per i VPS, stesso discorso riguardo la gestione. Per chi non ha valide conoscenze per l’amministrazione di un server, è consigliato affidarsi a servizi “managed“, ovvero gestiti interamente dallo staff dell’azienda hosting. (installazione, configurazione, gestione, aggiornamenti, patch sistema operativo, etc).

mercoledì 5 dicembre 2012

Git Automate Pull

Ciao

l'altro giorno mi sono ritrovato a dovere aggiornare tutti i 29 repository Git del un progetto su cui sto lavorando ... ODDIO che noia ... farli uno per uno .. allora mi sono detto ora automatizzo ... seee magari sembrava facile ma devo dire che ci ho messo un po a capire come poter passare al comando git pull le credenziali non dalla tastiera ed il tutto in un ciclo senza scrivere tutto a brodo che era brutto ... insomma alla fine il risultato è stato questo :

PullAll.bat

set ITEM_LIST=(repositoryFolder1 repositoryFolder2 repositoryFolder3  ... )
for %%i in %ITEM_LIST% do (
cd %%i
git pull | echo "<password>" > CON
cd ..
)

sabato 1 dicembre 2012

Object Cloning usando IL in C#


una delle cose più fastidiose che succede spesso nella programmazione in c# è quando ci si imbatte in un oggetto da modificare mantenendo in copia l'originale.
Questa difficoltà si manifesta poiché quasi sempre gli oggetti riassegnati vengono legati all'oggetto sorgente per riferimento*. 

Per risolvere questo noioso problema solitamente nei nostri progetti implementiamo dei metodi di "Clone" ossia dei metodi che ci copiano gli oggetti ( veriabili, classi, e quant'altro ) su un altro contenitore non collegato al primo.

A volte però ci sono oggetti per cui abbiamo grosse difficoltà perché magari non sono serializzabili o altro ... ma ecco che vi posto un po di metodologie che vi aiuteranno nella quasi totalità dei casi di Clonazione. 

IL (Intermediate Language) può essere utilizzato per clonare oggetti e non è affatto male, e può essere abbastanza performante. 

definiamo una Classe Person : 


  public class Person 
  { 
  private int _id; 
  private string _name; 
  private string _firstName; 
  private string _field1, _field2, _field3; 

  public Person() 
  { 

  } 

  public int ID 
  { 
  get { return _id; } 
  set { _id = value ; } 
  } 

  public string Name 
  { 
  get { return _name; } 
  set { _name = value ; } 
  } 

  public string FirstName 
  { 
  get { return _firstName; } 
  set { _firstName = value ; } 
  } 
  } 




Test Code: Il codice riportato di seguito è un bel pezzo di codice, leggete i commenti e capirete cosa vi è dichiarato.


  class Program 
  { 
  /// <summary> 
  /// Delegate handler that's used to compile the IL to. 
  /// (This delegate is standard in .net 3.5) 
  /// </summary> 
  /// <typeparam name="T1">Parameter Type</typeparam> 
  /// <typeparam name="TResult">Return Type</typeparam> 
  /// <param name="arg1">Argument</param> 
  /// <returns>Result</returns> 
  public delegate TResult Func<T1, TResult>(T1 arg1); 
  /// <summary> 
  /// This dictionary caches the delegates for each 'to-clone' type. 
  /// </summary> 
  static Dictionary<Type, Delegate> _cachedIL = new Dictionary<Type, Delegate>(); 

  /// <summary> 
  /// The Main method that's executed for the test. 
  /// </summary> 
  /// <param name="args"></param> 
  static void Main( string [] args) 
  { 
  DoCloningTest(1000); 
  DoCloningTest(10000); 
  DoCloningTest(100000); 
  //Commented because the test takes long ;) 
  //DoCloningTest(1000000); 

  Console.ReadKey(); 
  } 

  /// <summary> 
  /// Do the cloning test and printout the results. 
  /// </summary> 
  /// <param name="count">Number of items to clone</param> 
  private static void DoCloningTest( int count) 
  { 
  // Create timer class. 
  HiPerfTimer timer = new HiPerfTimer(); 
  double timeElapsedN = 0, timeElapsedR = 0, timeElapsedIL = 0; 

  Console.WriteLine( "--> Creating {0} objects..." , count); 
  timer.StartNew(); 
  List<Person> personsToClone = CreatePersonsList(count); 
  timer.Stop(); 
  Person temp = CloneObjectWithIL(personsToClone[0]); 
  temp = null ; 
  Console.WriteLine( "\tCreated objects in {0} seconds" , timer.Duration); 

  Console.WriteLine( "- Cloning Normal..." ); 
  List<Person> clonedPersons = new List<Person>(count); 
  timer.StartNew(); 
  foreach (Person p in personsToClone) 
  { 
  clonedPersons.Add(CloneNormal(p)); 
  } 
  timer.Stop(); 
  timeElapsedN = timer.Duration; 

  Console.WriteLine( "- Cloning IL..." ); 
  clonedPersons = new List<Person>(count); 
  timer.StartNew(); 
  foreach (Person p in personsToClone) 
  { 
  clonedPersons.Add(CloneObjectWithIL<Person>(p)); 
  } 
  timer.Stop(); 
  timeElapsedIL = timer.Duration; 

  Console.WriteLine( "- Cloning Reflection..." ); 
  clonedPersons = new List<Person>(count); 
  timer.StartNew(); 
  foreach (Person p in personsToClone) 
  { 
  clonedPersons.Add(CloneObjectWithReflection(p)); 
  } 
  timer.Stop(); 
  timeElapsedR = timer.Duration; 

  Console.WriteLine(); 
  Console.ForegroundColor = ConsoleColor.Green; 
  Console.WriteLine( "----------------------------------------" ); 
  Console.WriteLine( "Object count:\t\t{0}" , count); 
  Console.WriteLine( "Cloning Normal:\t\t{0:00.0000} s" , timeElapsedN); 
  Console.WriteLine( "Cloning IL:\t\t{0:00.0000} s" , timeElapsedIL); 
  Console.WriteLine( "Cloning Reflection:\t{0:00.0000} s" , timeElapsedR); 
  Console.WriteLine( "----------------------------------------" ); 
  Console.ResetColor(); 
  } 

  /// <summary> 
  /// Create a list of persons with random data and a given number of items. 
  /// </summary> 
  /// <param name="count">Number of persons to generate</param> 
  /// <returns>List of generated persons</returns> 
  private static List<Person> CreatePersonsList( int count) 
  { 
  Random r = new Random(Environment.TickCount); 
  List<Person> persons = new List<Person>(count); 
  for ( int i = 0; i < count; i++) 
  { 
  Person p = new Person(); 
  p.ID = r.Next(); 
  p.Name = string .Concat( "Slaets_" , r.Next()); 
  p.FirstName = string .Concat( "Filip_" , r.Next()); 
  persons.Add(p); 
  } 
  return persons; 
  } 

  /// <summary> 
  /// Clone one person object with reflection 
  /// </summary> 
  /// <param name="p">Person to clone</param> 
  /// <returns>Cloned person</returns> 
  private static Person CloneObjectWithReflection(Person p) 
  { 
  // Get all the fields of the type, also the privates. 
  FieldInfo[] fis = p.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic); 
  // Create a new person object 
  Person newPerson = new Person(); 
  // Loop through all the fields and copy the information from the parameter class 
  // to the newPerson class. 
  foreach (FieldInfo fi in fis) 
  { 
  fi.SetValue(newPerson, fi.GetValue(p)); 
  } 
  // Return the cloned object. 
  return newPerson; 
  } 

  /// <summary> 
  /// Generic cloning method that clones an object using IL. 
  /// Only the first call of a certain type will hold back performance. 
  /// After the first call, the compiled IL is executed. 
  /// </summary> 
  /// <typeparam name="T">Type of object to clone</typeparam> 
  /// <param name="myObject">Object to clone</param> 
  /// <returns>Cloned object</returns> 
  private static T CloneObjectWithIL<T>(T myObject) 
  { 
  Delegate myExec = null ; 
  if (!_cachedIL.TryGetValue( typeof (T), out myExec)) 
  { 
  // Create ILGenerator 
  DynamicMethod dymMethod = new DynamicMethod( "DoClone" , typeof (T), new Type[] { typeof (T) }, true ); 
  ConstructorInfo cInfo = myObject.GetType().GetConstructor( new Type[] { }); 

  ILGenerator generator = dymMethod.GetILGenerator(); 

  LocalBuilder lbf = generator.DeclareLocal( typeof (T)); 
  //lbf.SetLocalSymInfo("_temp"); 

  generator.Emit(OpCodes.Newobj, cInfo); 
  generator.Emit(OpCodes.Stloc_0); 
  foreach (FieldInfo field in myObject.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic)) 
  { 
  // Load the new object on the eval stack...  (currently 1 item on eval stack) 
  generator.Emit(OpCodes.Ldloc_0); 
  // Load initial object (parameter) (currently 2 items on eval stack) 
  generator.Emit(OpCodes.Ldarg_0); 
  // Replace value by field value (still currently 2 items on eval stack) 
  generator.Emit(OpCodes.Ldfld, field); 
  // Store the value of the top on the eval stack into the object underneath that value on the value stack. 
  // (0 items on eval stack) 
  generator.Emit(OpCodes.Stfld, field); 
  } 

  // Load new constructed obj on eval stack -> 1 item on stack 
  generator.Emit(OpCodes.Ldloc_0); 
  // Return constructed object.  --> 0 items on stack 
  generator.Emit(OpCodes.Ret); 

  myExec = dymMethod.CreateDelegate( typeof (Func<T, T>)); 
  _cachedIL.Add( typeof (T), myExec); 
  } 
  return ((Func<T, T>)myExec)(myObject); 
  } 

  /// <summary> 
  /// Clone a person object by manually typing the copy statements. 
  /// </summary> 
  /// <param name="p">Object to clone</param> 
  /// <returns>Cloned object</returns> 
  private static Person CloneNormal(Person p) 
  { 
  Person newPerson = new Person(); 
  newPerson.ID = p.ID; 
  newPerson.Name = p.Name; 
  newPerson.FirstName = p.FirstName; 
  return newPerson; 
  } 
  } 

La cosa fondamentale che fa è, creare un metodo dinamico, ottenere il ILGenerator, creare codice nel metodo, compilarlo per un delegato, ed eseguire il delegato. 

Il delegato è in cache cosi che l'IL non viene generato ogni volta che una clonazione dovrebbe avvenire, quindi perdiamo un solo poco tempo, quando il primo oggetto viene clonato (IL deve essere creato e compilato in fase di esecuzione). 

Speriamo che questo articolo sia utile per alcune persone se è così, fatemelo sapere. 

Saluti

c# Best Practice for Code Style

Spesso ci chiediamo quale sia il miglior stile di programmazione o quali sono gli errori in cui si incorre durante lo sviluppo .
ecco una buona guida a non commettere errori durante lo sviluppo ( best practises c# developing ) :
http://download.microsoft.com/download/e/2/1/e216b4ce-1417-41af-863d-ec15f2d31b59/dev320.ppt