Coach


In pieno rock ".net" roll
Anno 2011

Anno 2010

Anno 2009

Anno 2008

Anno 2007

Anno 2006

Anno 2005

Ordinare una Collection di base attraverso IComparer e la Reflection

Sempre di più nella mie applicazioni per rappressentare le mie entity non uso i dataset ma delle Collection Tipizzate come avevo già avuto modo di parlare nel post sulla CollectionBase.
Quindi mi sono creato una classe base per le collection che implementa le interfaccie, per creare collection e utilizzare il binding ovvero ICollection,IList e IEnumerable e attraverso un'arraylist carico la collection.

Fin qui niente di particolarmente difficile, invece diventa un pò più complicato quando bisogna implementare il metodo Sort dell'arraylist per poter ordinare la collection.
Per implementare il metodo Sort dell'arraylist dobbiamo implementare o l'interfaccia IComparable o l'interfaccia IComparer. Implementare queste interfaccie non è complicatissimo però dobbiamo sempre compare una singola proprietà che implementi IComparable, tutti i tipi primitivi implementano IComparable con il metodo CompareTo.
Bene visto che la mia collection è una classe di base dovevo farlo per tutte le proprietà(importante che implementino IComparable) e senza dover usare uno switch che è poco scalabile, quindi in questo caso mi è venuta ancora una volta in aiuto la Reflection.

Quindi mi sono creato una classe base che implementa l'interfaccia IComparer e che nel costruttore acetta il nome della proprietà e l'ogetto da ordinare e quindi nel metodo Compare ho fatto la comparazione dell'oggetto.
La classe è cosi fatta

[Serializable()]
public class BaseClassCompare : IComparer
{

#region
Private Fields
PropertyInfo propInfo;
#endregion
#region
Costructor
/// <summary>
/// Imposta la proprietà 
/// </summary>
/// <param name="key">la proprietà da ordinare</param>
/// <param name="item">l'oggetto da ordinare</param>
public BaseClassCompare(string key, object item)
{
//recupero la proprietà
Type _type = item.GetType();
propInfo = _type.GetProperty(key);

if (propInfo == null)
{
throw new ArgumentException("La proprietà non esiste",key);
}

}

#endregion
#region
Comparer
/// <summary>
/// Implementazione dell'interfaccia IComparer
/// </summary>
/// <param name="x">primo oggetto</param>
/// <param name="y">secondo oggetto</param>
/// <returns></returns>
public int Compare(object x, object y)
{

   IComparable a = (IComparable)propInfo.GetValue(x,
null);
   return a.CompareTo(propInfo.GetValue(y,null));
}
 

}

#endregion

}
// end class - BaseClassCompare


E poi nella mia Collection Base nel metodo Sort faccio
///
<summary>
/// Ordina la collection
/// </summary>
/// <param name="key">la proprietà da ordinare</param>
public void Sort(string key)
{
IComparer icomp =
new BaseClassCompare(key, myList[0],ascending);
this.myList.Sort(icomp);
}

dove myList è il mio ArrayList.
Forse con la reflection si perde un pò in prestazioni però se pensate che magari le vostre entità possano cambiare spesso direi che questo è la via migliore.
Categoria: .NET 1.1
martedì, 28 mar 2006 Ore. 19.05
  • Views Home Page: 260.178
  • Views Posts: 714.894
  • Views Gallerie: 315.215
  • n° Posts: 484
  • n° Commenti: 275












Copyright © 2002-2007 - Blogs 2.0
dotNetHell.it | Home Page Blogs
ASP.NET 2.0 Windows 2003