using System.Collections;
using System.Data;
namespace CARRS
{
#region Sort Enumerations
/// <summary>
/// Lookup Collection Sort Column
/// </summary>
public enum LookupCollectionSortColumn
{
Id,
SortNumber,
Description,
Code,
Value
}
/// <summary>
/// Lookup Collection Sort Direction
/// </summary>
public enum LookupCollectionSortDirection
{
Ascending,
Descending
}
#endregion
#region Lookup Collection
/// <summary>
/// Lookup Collection
/// </summary>
public class LookupCollection : ReadOnlyCollectionBase
{
#region Indexer
public Lookup this[int index]
{
get { return this[index]; }
}
#endregion
#region General Object Methods
public int IndexOf(Lookup ob)
{
return IndexOf(ob);
}
public bool Contains(Lookup ob)
{
return Contains(ob);
}
public bool Contains(int id)
{
foreach (Lookup ob in this)
{
if (ob.Id == id)
return true;
}
return false;
}
#endregion
#region Sort
public void Sort(LookupCollectionSortColumn sortColumn, LookupCollectionSortDirection sortDirection)
{
IComparer ob = new LookupCollectionComparer(sortColumn, sortDirection);
InnerList.Sort(ob);
}
public void Sort(LookupCollectionSortColumn sortColumn)
{
LookupCollectionComparer ob = new LookupCollectionComparer(sortColumn, LookupCollectionSortDirection.Ascending);
InnerList.Sort(ob);
}
public void Sort()
{
InnerList.Sort();
}
#endregion
#region Constructor
public LookupCollection(IDataReader dr)
{
while (dr.Read())
{
Lookup ob = Lookup.GetLookup(dr);
InnerList.Add(ob);
}
}
#endregion
}
#endregion
#region IComparer Implimentation
/// <summary>
/// Custom Lookup Collection Sort IComparer implimentation
/// </summary>
internal class LookupCollectionComparer : IComparer
{
private LookupCollectionSortColumn _sortColumn;
private LookupCollectionSortDirection _sortDirection;
public LookupCollectionComparer(LookupCollectionSortColumn sortColumn, LookupCollectionSortDirection sortirection)
{
_sortColumn = sortColumn;
_sortDirection = sortirection;
}
public int Compare(object x, object y)
{
Lookup Comparer, Comparee;
// define two objects, and sort direction switches their identity, thus switches order
if (_sortDirection == LookupCollectionSortDirection.Ascending)
{
Comparer = (Lookup)x;
Comparee = (Lookup)y;
}
else
{
Comparer = (Lookup)y;
Comparee = (Lookup)x;
}
// add more columns as defined
switch (_sortColumn)
{
case LookupCollectionSortColumn.SortNumber:
return Comparer.SortNumber.CompareTo(Comparee.SortNumber);
case LookupCollectionSortColumn.Description:
return Comparer.Description.CompareTo(Comparee.Description);
case LookupCollectionSortColumn.Code:
return Comparer.Code.CompareTo(Comparee.Code);
case LookupCollectionSortColumn.Value:
return Comparer.Value.CompareTo(Comparee.Value);
case LookupCollectionSortColumn.Id:
return Comparer.Id.CompareTo(Comparee.Id);
default:
return 0;
}
}
}
#endregion
}
Below is the child object code used by the parent. Notice that we still implement IComparable here as well, to allow for a default .Sort() call:
using System;
using System.Data;
namespace CARRS
{
[Serializable]
public class Lookup : IComparable<Lookup>
{
#region Private Members
private int _id = 0;
private string _code = string.Empty;
private string _value = string.Empty;
private string _description = string.Empty;
private bool _isActive = true;
private int _sortNumber = 0;
#endregion
#region Business Properties
public int Id
{
get
{
return _id;
}
}
public string Code
{
get
{
return _code;
}
}
public string Value
{
get
{
return _value;
}
}
public string Description
{
get
{
return _description;
}
}
public bool IsActive
{
get
{
return _isActive;
}
}
public int SortNumber
{
get
{
return _sortNumber;
}
}
#endregion
#region Overrides
public override string ToString()
{
return _id.ToString();
}
public bool Equals(Lookup ob)
{
return _id.Equals(ob.Id);
}
public override int GetHashCode()
{
return (_id.ToString()).GetHashCode();
}
#endregion
#region IComparable Implimentation
public int CompareTo(Lookup ob)
{
return _sortNumber.CompareTo(ob.SortNumber);
}
#endregion
#region Static Members
internal static Lookup GetLookup(IDataReader dr)
{
Lookup ob = new Lookup();
ob.Fetch(dr);
return ob;
}
#endregion
#region Constructor
private Lookup()
{
// Prevent direct creation
}
#endregion
#region Data Access
private void Fetch(IDataRecord dr)
{
//TODO: if we don't use CSLA.Data.SafeDataReader we will have to validate
_id = Convert.ToInt32(dr["ID"]);
_code = dr["Code"].ToString();
_value = dr["Value"].ToString();
_description = dr["Description"].ToString();
_isActive = Convert.ToBoolean(dr["IsActive"]);
_sortNumber = Convert.ToInt32(dr["SortNumber"]);
}
#endregion
}
}
Here is the class diagram for the above:
